Perl 6
Perl 6 Index Tablet: Revision 445
{section: Index} "Overview"[Perl 6 Tablets] - _Chapter:_ "0:History"[Perl 6 History Tablet], "1:Design"[Perl 6 Language Design Tablet], "2:Basics"[Perl 6 Basics Tablet], "3:Var"[Perl 6 Variable Tablet], "4:Op"[Perl 6 Operator Tablet], "5:IO"[Perl 6 IO Tablet], "6:{}"[Perl 6 Block Tablet], "7:Sub"[Perl 6 Subroutine Tablet], "8:OOP"[Perl 6 OOP Tablet], "9:Rx"[Perl 6 Regex Tablet], "10:Meta"[Perl 6 Meta Tablet]
"Intro"[Perl 6 Intro Tablet] - _Appendices:_ *"A:Index"[Perl 6 Index Tablet]*, "B:Tables"[Perl 6 Lookup Tablet], "C:Cook"[Perl 6 Cookbook Tablet], "D:Delta"[Perl 6 Delta Tablet], "E:Best of"[Best Of Perl 6 Tablet], "F:Links"[Perl 6 Links Tablet]

----

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

This index contains an alphanumeric sorted list (sorted without prefixes like colon, slash, sigil or twigil) of all operators, methods, builtins, options, modifier and special variables *(bold)* and some technical terms _(italic)_ with short explanations. Each bold term is followed by a link (in round brackets) to a condensed summary listing of its category in appendix B. Sometimes are added placeholder for parameter in angle brackets. _<n>_ stands for a integer number, _<f>_ is a floating point number, _<s>_ string, _<var>_ any variable, _<op>_ any operator and _<p>_ for a regex pattern.

Before alpha chars (a-z) come the other in ASCII order: *"!"#"{link: exclamation mark}* *"$%&"{link: dollar sign}* *"'(*"{link: single quotation marks}* *"+,-"{link: plus sign}* *"./0"{link: dot}* *":;<"{link: colon}* *"=>?"{link: equal sign}* *"@[\"{link: at sigil}* *"^_{"{link: caret}* *"|~"{link: pipe op}*

* *!* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ {section: exclamation mark} {section: exclamation mark op} - logical negation (_NOT_), forces boolean context (is a _"contextualizer"{link: contextualizer}_), high precedence version of *"not"{link: not}*
* *!* _"(twigil)"{link: [Perl 6 lookup tablet] Twigils}_ {section: exclamation mark twigil} - _"twigil"{link: twigil}_ of private class and object variables
* *!* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: exclamation mark signature} - "suffix"{link: suffix category} for a required parameter in signatures, thats default if it's a named parameter, not is it's a positional
* *!*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: exclamation mark metaop} - negates (mostly "comparison operators"{link: [perl 6 Operator tablet] Comparison} )
* *$!* - _"(special var)"{link: [perl 6 lookup tablet] Special Variables}_ {section: exclamation mark var} - last error message
* *<!>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: exclamation mark subrule} - inverse of *"<?>"{link: question mark subrule}*, returns always false
* *!!* {section: exclamation mark exclamation mark } - just second part of the ternary (conditional) operator after *"??"{link: ??}*, no op on its own
* *!!!* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple exclamation mark} - yadda operator that calls *"die"{link: die}*
* *"" ""{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: double quotation marks} - double quoting, interpolates with *":s"{link: s adverb}*, *":a"{link: a adverb}*, *":h"{link: h adverb}*, *":f"{link: f adverb}*, *":c"{link: c adverb}*, *":b"{link: b adverb}* (all vars, functions, blocks, control chars), alias to *"qq/.../"{link: qq op}* or *Q* *":qq"{link: qq adverb}* */.../*
* *"#"{link: [Perl 6 Basics Tablet]Single Line}* {section: pound} - starts a comment that continues to the end of the line; works even inside regexes as a _"regex metachar"{link: [perl 6 lookup tablet] Regex Metacharacter}_
* *"#="{link: [Perl 6 Basics Tablet] POD}* {section: pound equal} - starts comments to the lineending like *#*, just makes documenting comments that end up in _&routine.WHY.content_ on the following _"routine"{link: routine}_
* *"#`( )"{link: [Perl 6 Basics Tablet] Multi Line}* {section: pound apostrophe} - starts a multi-line comment that continues to the closing bracket, works with any combination of bracket pairs
* *"$"{link: [perl 6 Variable Tablet] Scalar}* _"(sigil)"{link: [Perl 6 lookup tablet] Sigils}_ {section: dollar sign} {section: dollar sigil} - "prefix"{link: prefix category} of "scalar variables"{link: [perl 6 Variable Tablet] Scalar}
* *$*() _"(context op)"{link: [perl 6 lookup tablet]Contextualizers}_ {section: dollar context op} - forces scalar context, alias to the *"item()"{link: item}* function
* *$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dollar metachar} - end of the string
* *$$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dollar dollar } - end of a line
* *%* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: percent sigil} - "prefix"{link: prefix category} of "hash variables"{link: [perl 6 Variable Tablet] Hash}
* *%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: percent} - gives remainder of a modulo division, forces numeric context
* *%*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: percent context op} - forces hash context, alias to the *"hash()"{link: hash}* function
* *%*<s> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: percent metachar} - quantifier that repeat char or group as long as separated by right expression - example: `\d % ','` matches `1,2,3,4,5`
* *%%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: percent percent } - *"True"{link: true}* if the left value is evenly divisible by the right value
* *%%*<s> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: percent percent metaop} - quantifier that repeat char or group as long as separated by right expression like %. but allows trailing separator - example: `\d %% ','` matches `1,2,3,4,5,`
* *"&"{link: [perl 6 Variable Tablet] Callable}* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: - _"sigil"{link: ampersand sigil} _ of "callable variables"{link: [perl 6 Variable Tablet] Callable} like "subs"{link: sub}, "methods"{link: method} and other "blocks"{link: block}
* *&* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: junctive and} {section: ampersand op} - junctive _AND_, requires that all conditions are met, see also: *"all"{link: all}*
* *&* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: ampersand metachar} - match multiple patterns (_AND_-connection of patterns)
* *&&* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: high and} {section: ampersand ampersand} - short circuit _AND_, evals right side if left side returns *"True"{link: true}*, high precedence version of *"and"{link: and}*
* *"' '"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: single quotation marks} - simple quoting, just / and ' must be escaped, alias to *"q/.../"{link: q op}* or *Q :q/.../*
* *()* {section: round brackets } - grouping of values (parameters)
* *()* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: round brackets metachar } - encompass a _subregex_ / _submatch_ , results land in *"@()"{link: round brackets var}* or *"$0"{link: 0 var}*... (not limited to $9 anymore)
* *@()* - _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: round brackets var} - holds positional submatches, *{{$()[n]}}* is alias to *"$/[n]"{link: match var}* and *"$n"{link: 0 var}*
* *{{*}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: asterisk op} - multiplies numbers, forces numeric context
* *{{*}}* _(term)_ {section: asterisk} - synonym for *"Whatever"{link: Whatever}*, for example, means `Inf` in a "range operator"{link: 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
* *{{*}}* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: asterisk signature} - "prefix"{link: prefix category} which indicates _slurpy_ arrays in signatures
* *{{*}}* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: asterisk twigil} - _"twigil"{link: twigil}_ of global variables
* *{{*}}* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk metachar} - quantifier for zero or more findings
* *{{**}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: asterisk asterisk op} - raises a number to a power, forces numeric context
* *{{**}}* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk asterisk op} - not backtracking, greedy quantifier taking zero or more findings
* *{{**}}*<n> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk asterisk metaop} - quantifier for explicit repeat char or group, like *"x"{link: x}* _(string op)_ does outside of a regex; for example, `(ha)**3` matches `(hahaha)`
* *+* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus sign} {section: plus op} - "infix"{link: infix category} addition operator, forces "numeric context"{link: numeric context}
* *+* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: plus metachar} - quantifier for one or more findings
* *+&* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus ampersand} - bitwise _AND_, forces numeric context
* *++* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: plus plus} {section: double plus} - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the "evaluation"{link: evaluation} of the surrounding term, alias to *"succ"{link: succ}*
* *+<* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus lower} - shift left in numeric context
* *+>* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus greater} - shift right in numeric context
* *+^* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus caret} - bitwise _XOR_ in numeric context
* *+|* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus pipe} - bitwise _OR_ in numeric context
* *","{link: [perl 6 Variable Tablet] Array}* {section: comma} - "list"{link: [perl 6 Variable Tablet] Array}-generating operator
* *{{-}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: minus op} - "infix"{link: infix category} subtraction operator, forces numeric context (and negates)
* *--* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: minus minus op} - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the "evaluation"{link: evaluation} of the surrounding term, alias to *"pred"{link: pred}*
* *-->* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: minus minus greater signature} - declares the type of the return value of a routine, type name is placed after this arrow at the end of a signature
* *{{->}}* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: minus greater} {section: arrow op} - declares named parameters for a block (pointy block)
* *.* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: dot} {section: dot twigil} - _"twigil"{link: twigil}_ of public accessors (getter/setter)
* *.* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dot metachar} - matches any character (including a newline, unlike in Perl 5)
* *..* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_, _"(list op)"{link: [perl 6 Operator tablet] List generation}_ {section: range op} {section: dot dot} - "infix"{link: infix category} range generating operator, produces a `Range` object in "item context"{link: [perl 6 lookup tablet]Contextualizers}
* *"..."{link: [perl 6 Operator tablet] Sequence Operator}* _"(list op)"{link: [perl 6 Operator tablet] List generation}_ {section: triple dot op} - "infix"{link: infix category} sequence generating operator, infix operator for list generation
* *...* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple dot yadda op} - term that calls *"fail"{link: fail}* (exception), marks unimplemented empty routine bodies
* */* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: slash} {section: slash op} - divides numbers, forces numeric context
* */* _"(rat composer)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: slash rat op} - inside round brackets (for example `(3/7)`), gives you a rational number ( "immutable type"{link: [Perl 6 Lookup Tablet]immutable types} ) that keeps track of its numerator and denominator
* *$/* - _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: slash var} {section: match var} - last created match object of this block
* *//* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: high err} {section: slash slash op} - short circuit _defined or_, returns the first defined value (from left to right), similar to *"||"{link: pipe pipe op}*, high precedence version of *"err"{link: err}*
* *{{\0}}*_B_*{{[<n>]}}* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash 0} - character given in octal, decimal or hex (when _B_ is 'o', 'd' or 'x'), brackets are optional, first number has to be inside okt/dec/hex range, alternate syntax without the zero is preferred
* *{{$0}}* _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: 0 var} - first positional submatch, there is *$1*, *$2*, ... too (don't stops at *$9* like Perl 5), alias to *"$()[0]"{link: round brackets var}* and *"$/[0]"{link: backslash var}*, former $0 is now *"$*EXECUTABLE_NAME"{link: EXECUTABLE NAME global var}*
* *:* {section: colon} - _"pair"{link: [perl 6 variable tablet] pair}_ generation operator, also known as _adverbial_ syntax
* *:* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: colon filetest} - start of all file test ops - example: _{{":"}} ~ one (<r w x o R W X O e z s f d l p S b c t u g k T B M A C>)_
* *:* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: colon twigil} - _"twigil"{link: twigil}_ of autogenerated named parameters of a block
* *:*_B_*<N>* {section: colon number} - "general radix form"{link: [Perl 6 Basics Tablet]General Radix Form} for literals, makes a number N in base B (up to 36) - example: `:2<1000001>` is decimal 65
* *:*<s> _(flow control)_ {section: colon label} - suffix of all labels you can jump to with *"goto"{link: goto}*
* *:* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: colon signature} - prefix of a _"named parameter"{link: named parameter}_ in a signature, they are positional when without colon
* *::* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: colon colon sigil} - abstraction "sigil"{link: sigil} and namespace separator in variable/routine/namespace names (like in Perl 5)
* *::* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: colon colon signature } - introducing a type variable in a signature
* *"::="{link: [Perl 6 Variable Tablet] Binding}* {section: colon colon equal op} - "binds"{link: [Perl 6 Variable Tablet] Binding} a value or variable to a variable at compile time
* *":="{link: [Perl 6 Variable Tablet] Binding}* {section: colon equal op} - creates an alias to a variable at runtime (_"binding"{link: [Perl 6 Variable Tablet] Binding}_)
* *";"{link: [Perl 6 Basics Tablet] Statements}* {section: semicolon} - separates "statements"{link: [Perl 6 Basics Tablet] Statements} (commands) or "array indices"{link: [Perl 6 Variable Tablet] Array Slices}; for example, `@[2;3]` instead of `@a[2][3]`
* *<* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: lower op} - "infix"{link: infix category} op, less than, *"True"{link: true}* if numerically ordered the left comes before the right operand
* *{{<->}}* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: lower minus greater signature} double pointy syntax to assign a rw parameter to a block*
* *<<* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: lower lower metaop} - applies the operator on the left as hyper operator to the array on the right
* *<<==* {section: lower lower equal equal op} - leftward pointing feed operator that adds values to an existing list (append-mode)
* *"<< >>"{link: [Perl 6 Basics Tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: double angle brackets} - "circumfix"{link: circumfix category} quoting operator for grouping with autoquoting and evaluation of variables, alias to *Q* *":qq"{link: qq adverb}* *:ww* */.../*
* *<=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: lower equal op} - less than or equal, numeric comparison operator see also *<* and *>=*
* *<==* {section: lower lequal equal op} - leftward pointing feed operator, take return value of right side and feed as parameter to the left (see also ==> )
* *<=>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: spaceship op} {section: lower equal greater op} - numeric less-equal-greater comparison for sortable classes, does *"cmp"{link: cmp}* in numeric context as *"leg"{link: leg}* does in string context
* *"< >"{link: [Perl 6 Basics Tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: angle brackets} - "circumfix"{link: circumfix category} quoting operator for grouping with autoquoting, alias to *"Q"{link: capital Q op}* *:q* *:ww* */.../* or *"qw/.../"{link: qw op}*
* *< >* _"(twigil)"{link: [Perl 6 lookup tablet] Twigils}_ {section: angle brackets twigil} - "circumfix"{link: circumfix category} _"twigil"{link: twigil}_ of named captures, *$<...>* is alias to *"$/<...>"{link: match var}*, was $& and $MATCH in Perl 5
* *< >* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: angle brackets metachar} - embraces an subrule (assertion)
* *"="{link: [Perl 6 Variable Tablet] Assignment}* _(Op)_ {section: equal sign} {section: equal op} - "assignment"{link: [Perl 6 Variable Tablet] Assignment}, right side is "evaluated"{link: evaluation} and assigned to the left
* {{<op>}} *=* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: equal metaop} - self assignment, left side is one operand and place where the result is assigned to - example: _($a += 3; equals $a = $a + 3)_
* *=:=* _(comparison op)_ {section: equal colon equal op} - compares "binding"{link: [Perl 6 Variable Tablet] Binding}, if both vars are bound to same memory location
* *==* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: equal equal op} - *"True"{link: true}* if values are equal in numerical context, as *"eq"{link: eq}* does in string context
* *===* _(comparison op)_ {section: triple equal} - identity, equality of value and type
* *==>* _(op)_ {section: equal equal greater op} - rightward pointing feed operator, take return value of left side and feed as parameter to the right
* *==>>* _(op)_ {section: equal equal greater greater op} - rightward pointing feed operator that adds values to an existing list (append-mode)
* *=>* _(op)_ {section: fatarrow} {section: equal greater op} - pair (and hash) constructor, _fatarrow_
* *>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: greater op} - "infix"{link: infix category} op, numeric greater than
* *>=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: greater equal op} - "infix"{link: infix category} op, numeric greater than or equal
* *>>* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: greater greater op} - binds operator (right) as hyper operator to an array (left)
* *"?"{link: [perl 6 Operator tablet] logical selection}* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: question mark op} - forces binary context in an expression, returns *"False"{link: False}* when value is 0 or empty, otherwise *"True"{link: True}*, high precedence version of *"so"{link: so op}*
* *?* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ {section: question mark signature} - suffix for optional named parameters in signatures
* *?* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: question mark metachar} - quantifier for 0 or 1 occurrence in Regexes
* *?* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: question mark twigil} - _"twigil"{link: twigil}_ (secondary sigil) for constant compiler hint variables
* *<?>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: question mark subrule} - matches nothing, returns always *"True"{link: true}*, opposite of *"<!>"{link: exclamation mark subrule}*
* *?&* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark ampersand op} - logical _AND_ op, and combinator, forces binary context
* *?? !!* (logical op) {section: question mark question mark} {section: ternary op} - ternary or conditional operator; shortcut for *"if"{link: if}* and *"else"{link: else}*
* *???* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple question mark} - yadda operator that calles *"warn"{link: warn}*
* *?^* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark caret op} - logical _XOR_, forces operands into boolean context
* *?|* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark pipe op} - logical _OR_, forces operands into boolean context
* *@* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: at sigil} - "sigil"{link: sigil} of an "array"{link: [perl 6 Variable Tablet] Array}
* *@*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: at context op} - forces (flattened) array context, alias to *"list()"{link: list}* function
* *<var>[ ]* {section: square brackets slice op} - "postcircumfix"{link: postcircumfix category} operator, appended on an array var, returns an array slice with values which indexes was inside the brackets
* *[ ]* {section: square bracket} - "circumfix"{link: circumfix category} operator that creates a reference to an array that holds all values that encompas these brackets
* *{{[<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: square bracket metaop} - "circumfix"{link: circumfix category} reduction metaop, applies the operator between all elements of an array, alias to *"reduce"{link: reduce}*
* *{{[\<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: square bracket slash metaop} - "circumfix"{link: 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"{link: triangle}*
* *\* {section: backslash op} - "capture generator"{link: [perl 6 variable tablet] Capture}, creates a _"capture"{link: capture}_ that holds the following structure
* *\* {section: backslash} - escape char, all escape sequences inside "quotes"{link: [perl_6_lookup_tablet] Control Chars} and "regexes"{link: [perl_6_lookup_tablet] Escape Sequences} start with it
* *^* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: junctive xor} {section: caret op} - junctive _XOR_, requires that one value in a list is *"True"{link: true}*, see also *"one"{link: one}*
* *^* {section: caret range op} - upto operator, ^$limit expands to 0 ..^ +$limit range
* *^* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_ {section: caret range metachar} - in "range"{link: range op} definitions, it excludes a limit value, in scalar context see smartmatch
* *^* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: caret twigil} - for autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables
* *^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: caret metachar} - start of the string
* *^^* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: double caret op} - logical _XOR_, combines expressions, returns *"True"{link: true}* when only one expression is true, otherwise false, high precedence version of *"xor"{link: xor}*
* *^^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: double caret metachar} - start of a line
* *{{$_}}* _"(special var)"{link: [perl 6 lookup tablet] Special Variables}_ {section: underscore} {section: context var} - context var, result of the last command, can set by topicalizers (*"given"{link: given}* and *"for"{link: for}*)
* *{}* {section: curly brackets} - "circumfix"{link: circumfix category} operator, encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a *"=>"{link: fatarrow}*
* *|* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: pipe op} {section: junctive or} - junctive _OR_, requires that a condition is fulfilled, see also: *"any"{link: any}*
* *|* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: pipe metachar} - match alternate patterns with longest token matching (OR - temporal simultaneous connection of patterns)
* *|*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: pipe context op} - flatten "capture"{link: [perl 6 variable tablet] Capture} object into arglist, (named parameter)
* *||* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: pipe pipe op} {section: high or} - short circuit _OR_, evaluates sequentially, ends evaluation at the first expression that returns *"True"{link: true}*, high precedence version of *"or"{link: or}*
* *||* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: pipe pipe metachar} - match alternate patterns (temporal consequent alternatives) as connected with a logical _OR_
* *||*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: pipe pipe context op} - flatten "capture"{link: [perl 6 variable tablet] Capture} object into semicolon list, (positional parameter)
* *"~"{link: [perl 6 Operator tablet] String Context}* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde} {section: tilde op} - forces string context (stringify) and/or concatenate strings, synonym for cat
* *~* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: tilde twigil} - _"twigil"{link: twigil}_ for a "grammar"{link: grammar} of a sublanguage
* *~&* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde ampersand op} - characterwise _AND_, forces string context
* *~<* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde lower op} - characterwise left shift, forces string context
* *~>* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde greater op} - characterwise right shift, forces string context
* *~^* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde caret op} - characterwise _XOR_, forces string context
* *~|* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde pipe op} - characterwise or, forces string context
* *"~~"{link: [perl 6 Operator tablet] smartmatch}* _(comparison op)_ {section: smartmatch op} {section: tilde tilde op} - smartmatch operator, compares (almost) all variable and data types according a "table"{link: [Perl 6 Lookup Tablet] smartmatch}

^^ "A"{link: Index} {section: A}

* *:a* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: a adverb} - demands evaluation of array variables that starting with the *"@-sigil"{link: at sigil}*, short form of *":array"{link: array adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *abs* _(numeric op)_ {section: abs} - returns numeric absolute value
* *after* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: after} - generic comparison operator used by the Order class, *"True"{link: true}* if left should follow right
* *<?after <p>>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: after subrule} - zero-width lookbehind
* *all* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: all} - junctive _AND_ operator, *"True"{link: true}* if all conditions (elements of a following list) are fulfilled, see also: *"&"{link: junctive and}*
* *<alnum>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: alnum} - a single alphanumeric character, equivalent to *<+alpha +digit>*
* *<alpha>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: alpha} - a single alphabetic character
* *and* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: and} - short circuit logical _AND_, returns the last defined value (from left to right), low precedence version of *"&&"{link: high and}*, similar to *"andthen"{link: andthen}*
* *andthen* _(logical op)_ {section: andthen} - logical _AND_ short circuit operator, transferring *"$_"{link: context var}* from first to second block/expression, if first do succeed, see also: *"orelse"{link: orelse}*
* *anon* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: anon} - introduces names that aren't to be stored anywhere (anonymous)
* *Any* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Any type} - Perl 6 object (default routine parameter type, excludes junction)
* *any* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: any} - junctive _OR_ operator, *"True"{link: true}* when any one condition (of a following list) is true in bool context, see also: *"|"{link: junctive or}*
* *{{$*ARGFILES}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: argfiles global var} - magic command-line input handle, was ARGV in P5
* *{{@*ARGS}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: args global var} - arguments (parameter) to a program (script), formerly @ARGV
* *arity* _(routine method)_ {section: arity} - returns how many parameters this routine requires, *".count"{link: count}* includes also the optional
* *Array* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Array type} - Perl Array, a series of *"Scalar"{link: scalar type}* value container, or a variable that stores such a list
* *":array"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: array adverb} - demands evaluation of array variables that starting with the *"@-sigil"{link: at sigil}*, long form of *":a"{link: a adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *as* _"(parameter trait)"{link: [Perl 6 lookup tablet]parameter Traits}_ {section: as parameter trait} - data coming through that parameter will be coerced to the type following *as*
* *as* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ {section: as routine trait} - inner type constraint that a routine imposes on its return value
* *assoc* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ {section: assoc} - specifies the "associativity of an operator"{link: [Perl 6 Lookup tablet]operator associativity} explicitly
* *assuming* {assuming}- method of all subroutine reference objects that enables Currying
* _AST_ {section: AST} - (abstract syntax tree), tree like data structure, in which source code is transformed, before running the programm
* *async* _(block modifier)_ {section: async} - allows the interpreter to parallelize the following
* *augment* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: augment} - adds definitions to an existing name, inserts new methods and attributes into a *"grammar"{link: grammar}* or replaces them, see also: *"supersede"{link: supersede}*

^^ "B"{link: Index} {section: B}

* *:b* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: b filetest} - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)
* *:b* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: b adverb} - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, short form of *":backslash"{link: backslash adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *\B* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital B} - Match when not on a word boundary
* *\b* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash b} - zero-width word boundary aka *"<wb>"{link: wb subrule}*
* *":backslash"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: backslash adverb} - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, long form of *":b"{link: b adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* _backtracking_ {section: backtracking} - go after an unsuccessful match back to the last successful matching position and check if another alternative part of the regex matches
* *Bag* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bag type} - unordered collection of values that allows duplicates
* *base* {section: base} - returns a *"Str"{link: str type}* representing the invocant in base $base (only parameter); Fails if $base is smaller than 2 or larger than 36
* *before* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: before} - generic comparison operator used by the Order class, *"True"{link: true}* when left should precede right
* *<?before <p>>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: before subrule} - zero-width lookahead
* *BEGIN* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: BEGIN phaser} - marks a special block or statement, executed at compile time, ASAP, only ever runs once
* _"binding"{link: [Perl 6 Variable Tablet] Binding}_ {section: binding} - making two variables share the same content by pointing to same memory location
* *Bit* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bit type} - Perl single bit (allows traits, aliasing, undef, etc.)
* *<blank>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: blank} - a single "blank" character -- in most locales, this corresponds to space and tab
* *bless* {section: bless} - calling bless on any invocant (but typically a type object) to create a new object with the same class as the invocant
* *Blob* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: blob type} - An undifferentiated mass of bits
* *Block* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: block type} - Executable objects that have lexical scopes (enclosed by curly brackets)
* _block_ {section: block} - syntactically just a piece of code inside curly brackets (*{}*), when "evaluated"{link: evaluation} it becomes an object of the type *Block*
* *{{&?BLOCK}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: block compiler var} - reference to current block
* *Bool* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bool type} - Perl boolean, can be *"True"{link: True}* or *"False"{link: False}*
* *break* _"(flow control)"{link: [perl 6 lookup tablet] Jump Commands}_ {section: break} - leave this when clause block now (see also *"leave"{link: leave}*)
* *Buf* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: buf type} - Perl buffer (a stringish array of memory locations), type for raw binary data
* *but* {section: but} - adds a *"role"{link: role}* to a *"class"{link: class}*
* *bytes* _(string method)_ {section: bytes} - returns number of bytes used (a sort of length)
* *:bytes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: bytes modifier} - searching on byte level, (see also chars, codes, graphs)

^^ "C"{link: Index} {section: C}

* *:c* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: c filetest} - file is a character special file (e.g. terminals modems)
* *:c* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: c adverb} - forces evaluation of closures (blocks aka {{{...}}}) inside quotes, long form of *":closure"{link: closure adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *:c*(<n>) _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: c modifier} - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"
* *\C[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital C} - any character except the bracketed named or control character
* *\c[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash c} - named character or control character
* *|c* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: pipe c} - codepoint boundary, zero width space between two unicode codepoints, see also: *"|g"{link: pipe g}* and *"|w"{link: pipe w}*
* *cached* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: cached} - marks a subroutine as being memoized
* *call* {section: call} - execute a subroutine
* *caller* {section: caller} - object describing the code from which as routine was invoked
* *callframe* {section: callframe} - returns an object that describes a particular call frame as described by a list of matchers
* *callwith* {section: callwith} - submethode by which one can call a sub with a different "signature"{link: signature}
* *capitalize* {section: capitalize} - alias to a wordwise ucirst( lc( *"$_"{link: context var}* ) ), makes first char of every word upper case, rest lowercase
* *"Capture"{link: [perl 6 variable tablet] Capture}* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: capture type} - type holding arguments for a routine call (right-hand side of a binding)
* *cat* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: cat} - converts values of a list into string context and joines them like with '~', alias to _.join('')_
* *CATCH* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CATCH phaser} - marks a special block to catch exceptions, before *"LEAVE"{link: LEAVE phaser}*
* *categorize* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: categorize} - 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"{link: classify}* the return value of the mapper can be listref to put the value in several categories or *"Nil"{link: Nil}* to reject the value for categorisation
* *category* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: category category} - grammatical category of all grammatical categories (metacategory), useful in case you want to create a new one with a macro
* *"ceiling"{link: [perl 6 Operator tablet]}* {section: ceiling} - lowest integer not less than $x (only parameter)
* *char* _(num method)_ {section: char} - convert number into charakter according a character table, reverse of _ord_
* *chars* _(string method)_ - returns number of characters {section: ch} of a "string"{link: str type}, was length in Perl 5
* *:chars* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: chars modifier} - searching on character level (default), (see also bytes, codes, graphs)
* *"chdir"{link: [Perl 6 IO tablet] dir}* {section: chdir} - changes the current working directory (*"$*CWD"{link: cwd global var}*)
* *CHECK* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CHECK phaser} - marks a special block or statement, executed at compile time, ALAP, only ever runs once
* *chmod* {section: chmod} - changes access rights of files
* *chomp* _(string method)_ {section: chomp} - returns a "string"{link: str type} with the last newline (if there is one) removed (from only parameter)
* *chop* _(string method)_ {section: chop} - returns a "string"{link: str type} with the last character removed (from only parameter)
* *chown* {section: chown} - changes owner of files
* *"chroot"{link: [Perl 6 IO tablet] chroot}* {section: chroot} - change root directory on POSIX systems
* *circumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: circumfix category} - operator namespace of two parted ops that surround the statement, op or variable they affect, most prominent example may be the "double quotes"{link: double quotation marks}
* *class* _(block modifier)_ {section: class} - declares a collection of methods that define an object
* *{{$?CLASS}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: class compiler var} - current class object
* *{{::?CLASS}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: class package compiler var} - name of the current class
* *classify* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: classify} - 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"{link: categorize}*)
* *"close"{link: [Perl 6 IO tablet] close}* _(filehandle method)_ {section: close} - releasing the connection to a file via a file handler
* *":closure"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: closure adverb} - forces evaluation of closures (blocks aka {{{...}}}) inside quotes, long form of *":c"{link: c adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* _closure_ {section: closure} - routines whose state (content of all local variables) is completely preserved until the next execution
* *cmp* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: cmp} - general "infix"{link: infix category} sort comparator, result is _Order::Increase_ {{(numerically -1)}} if *"before"{link: before}* is *"True"{link: True}* - _Order::Same_ (numerically 0) if *"eqv"{link: eqv}* - _Order::Decrease_ (numerically 1) if *"after"{link: after}*, see also: *"leg"{link: leg}* and *"<=>"{link: spaceship op}*)
* *<cntrl>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: cntrl subrule} - a not visible character that is aimed to control the console output
* *Code* {section: Code} - data typ for code references of any kind
* *:code* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: code adverb} - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi
* _coderef_ {section: coderef} - reference (pointer) to an executable block of code (routine)
* *:codes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: codes modifier} - searching on codepoint level (between codepoints), (see also bytes, chars, graphs)
* *comb* _(string method)_ {section: comb} - $str.comb(/pattern/) equals {{ $str ~~ m:g/pattern/ }}, except it returns the list of findings, not a match object like *.match(rx/.../)* aka *"m/.../"{link: m op}*, default pattern is rx/./
* *{{@=COMMENT}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: comment pod var} - all the comment blocks in the file
* _compile time_ {section: compile time} - the process when Perl converts source code to executable form
* *Complex* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: complex type} - Perl complex number
* *"conjugate"{link: [perl 6 Operator tablet]}* {section: conjugate} - convert "complex number"{link: complex type} into real (*"Numeric"{link: num type}* type), see also *"abs"{link: abs}*
* *constant* _(var trait)_ {section: constant} - makes so declared var (_is constant_) a real constant
* *contend* _(block modifier)_ {section: contend} - marks a block as atomic, concurrent proceses have to wait
* _context_ {section: context} - when executing a function or operator Perl considers the expression from which the call was to return a "scalar"{link: scalar type} or other kind of result
* _context variable_ {section: context variable} - name for *"$_"{link: context var}*, which is used by built in Perl functions as an implicit parameter and as memory of the last result
* *"continue"{link: [Perl 6 Block tablet] continue}* _(flow control)_ {section: continue} - makes execution in a 'given' also try the following 'when' clauses
* *:continue*(<n>) - _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: continue modifier} - searching from nth (n is an int) position (counting from 0) and then going to the right, short for *":c"{link: c modifier}*
* *CONTROL* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CONTROL phaser} - marks a special block to catch control exceptions (like next/last/return etc), before *"LEAVE"{link: LEAVE phaser}*
* *Cool* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Cool type} - Perl 6 Convenient OO Loopbacks,
* *copy* _"(parameter trait)"{link: [Perl 6 lookup tablet] parameter traits}_ {section: copy} - read-writable copy of the original argument ("pass-by-value")
* *cos* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: cos} - cosine, trigonometric function, takes angle in radians; see also *"to-radians"{link: to-radians}*, *"sin"{link: sin}*, *"tan"{link: tan}*
* *count* _(routine method)_ {section: count} - returns how many parameters this routine takes (including optional), *".arity"{link: arity}* counts just the required
* *cross* _(list method)_ {section: cross} - alias to *"X"{link: capital X}* operator - example: {{ @a X @b = (@a; @b).cross }}
* *crosswith* _(list method)_ {section: crosswith} - alias to *"X"{link: capital X metaop}* metaoperator: {{ @a X~ @b = (@a; @b).crosswith(&[~]) = (@a; @b).cross.slice.map { .reduce(&[~]) } }}
* _currying_ {section: currying} - creating a subroutine as a derivate from another with certain parameter to be predefined
* *{{$*CWD}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: cwd global var} - current working directory ("Str"{link:str type})

^^ "D"{link: Index} {section: D}

* *:d* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: d filetest} - check if file is a directory
* *\D* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital D} - a single nondigit character
* *\d* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash d} - a single digit character
* *{{$=data}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: data scalar pod var} - handle for the data block (=begin data ... =end data)
* *{{@=data}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: data array pod var} - lines of the data block (=begin data ... =end data)
* *"decode"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: decode} - transforms raw binary UTF (*"Buf"{link: buf type}*) into readable UTF Text (*"Str"{link: str type}*)
* *"default"{link: [Perl 6 Block tablet] default}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: default} - following block will be executed if no when clause in surrounding block matched
* _Declarative Programming_ {section: Declarative Programming} - programming paradigm that expresses the logic of a computation without describing its control flow
* *defer* _(block modifier)_ {section: defer} -
* *defined* {section: defined} - scalar method tests whether a value has been assigned to a variable
* *delete* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: delete} {section: array delete} - removes all values of which indices are passed
* *delete* _(hash method){link: [Perl 6 Variable Tablet]Hash Methods}_ {section: hash delete} - removes all "pairs"{link: pair} of which keys are passed
* *denominator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: denominator} - returns the denominator of a rational number (value type Rat and FatRat)
* _Design by Contract_ {section: Design by Contract} - programming style in which parameters and return values from routines must meet conditions; A signature is considered contract in Perl 6
* *die* {section: die} - throws a fatal Exception, the default exception handler *"print"{link: print}*'s each element of the list to *"$*ERR"{link: err global var}*
* *<digit>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: digit subrule} - single (decimal) digit char aka *"\d"{link: backslash d}*
* *"dir"{link: [Perl 6 IO tablet] dir}* {section: dir} - returns all files of a given directory, excluding . and .. by default
* *{{$*DISTRO}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: distro global var} - running OS distribution, you might want to use _$DISTRO.name_, see also: *"$*KERNEL"{link: kernel global var}* and *"$*VM"{link: vm global var}*
* *{{$?DISTRO}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: distro compiler var} - "OS"{link: kernel compiler var} distribution the program was compiled for, see also: *"$?KERNEL"{link: kernel compiler var}* and *"$*VM"{link: vm compiler var}*
* *"div"[Perl 6 Operator Tablet]* {section: div} - integer division
* *"do"{link: [Perl 6 Block tablet] do}* {section: do} - executes a block (do once loop)
* *does* {section: delete}- checks if an objekt inherits a role (parameter)
* *dotty* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: dotty category} -
* *":double"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: double adverb} - _double quoting_, *q* with interpolation of variables, alias to *""...""{link: double quotation marks}*, *"qq /.../"{link: qq op}* and *Q :s :a :h :f :c :b /.../*, long for *":qq"{link: qq adverb}*
* *Duration* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: duration type} - The difference between two Instants
* *dynamic* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: dynamic} - parameter is an "environmental" variable, a lexical in the dynamic scope

^^ "E"{link: Index} {section: E}

* *:e* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: e filetest} - tests if file exists
* *\E* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital E} - anything but an escape character
* *\e* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash e} - escape character
* *each* {section: each} - variant of all() that promises to do things in order, is Positional/Iterable
* *eager* {section: eager} - forces eager evaluation (compute all values now), default for scalars - not for lists
* *{{$*EGID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: egid global var} - effective global ID of the running process (*"$*PID"{link: pid global var}*) owner, was @) and $EGID in Perl 5
* *elems* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: elems} {section: array elems} - number of elements (values), *"end"{link: end}*
* *elems* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: elems hash} - number of pairs
* *"else"{link: [Perl 6 Block tablet] else}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: else} - introduces the alternative block after an *"if"{link: if}* or *"elsif"{link: elsif}*, that is executed, when conditions of all alternatives resulted in *false* (see also *default*)
* *"elsif"{link: [Perl 6 Block tablet] elsif}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: elsif} - alternative if clause
* *"encode"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: encode} - transforms readable UTF Text (*"Str"{link: Str type}*) into raw binary UTF (*"Buf"{link: buf type}*)
* *END* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: END phaser} - marks a special block, executed at run time, ALAP, only ever runs once
* *end* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: end} - last index of that list, see also: *"elems"{link: elems}*
* *ENTER* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: ENTER phaser} - marks a special block or statement, executed at every block entry time, repeats on loop blocks
* *Enum* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Enum type} - An immutable Pair
* *enum* {section: enum} - enum takes a list of keys or pairs and adds values to any keys that are not already part of a pair (one more than the previous key had) - example: _{{%hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;}}_
* *EnumMap* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Enummap type} - A mapping of Enums with no duplicate keys
* *{{%*ENV}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: env global var} - environment variables (of the shell), was %ENV in P5
* *eq* _"(comparison op)"{link: [perl 6 Operator tablet] String Comparison}_ {section: eq} - "infix"{link: infix category} operator, proves equality in forced string context as does *"="{link: equal equal op}* in numeric context
* *equiv* _"(routine trait)"{link: [Perl 6 Lookup Tablet]Routine Traits}_ {section: equiv} - specifies the "precedence of an operator"{link: [Perl 6 lookup tablet]Table of Precedence} same as an existing operator
* *eqv* _(comparison op)_ {section: eqv} - "infix"{link: infix category} operator, compares the dynamic state of objects and values, in contrast with static *"="{link: triple equal}*
* *err* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: err} - short circuit defined or, returns the first defined value from the left, short circuit or,low precedence version of *"//"{link: high err}*
* *{{$*ERR}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: err global var} - standard error output (command line mostly), STDERR in Perl 5
* *{{$*EUID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: euid global var} - effective user ID of the running process (*"$*PID"{link: pid global var}*) owner, was @> and $EUID in Perl 5
* *eval* {section: eval} - just evaluates a "string"{link: str type} as a program and returns result and maybe error message in *"$!"{link: exclamation mark var}*, second optional parameter defines a parser grammar which should understand the string
* _evaluation_ {section: evaluation} - reading the human written source code and make it an executable (piece of) program
* *evalfile* {section: evalfile} - evals a file like "do" did in Perl 5, with optional second parameter, which is a grammar that can parse that file
* *:ex* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ex modifier} - searching at all positions as long as it findes something (with backtracking), short for *":exhaustive"{link: exhaustive modifier}*
* *Exception* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: exception type} - Perl exception, errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle
* *:exec* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: exec adverb} - quoted string will be evaluated as Perl code (like *"eval"{link: eval}*) replaced with its result, alias to *Q :x* and *"qx/.../"{link: qx op}*
* *{{$*EXECUTABLE_NAME}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: executable name global var} - name of the main scripts file name, was _$0_ in Perl 5
* *:exhaustive* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: exhaustive modifier} - searching at all positions as long as it findes something (with backtracking), long for *":ex"{link: ex modifier}*
* *exists* {section: exists} - checks for existence of a variable, array or hash member, scalar method
* *exit* _(flow control)_ {section: exit} - stops all program execution, and returns Int $status (first parameter) to the calling environment
* *exp* {section: exp} - exponentiate, alias method to: $base (first parameter) *"**"{link: asterisk asterisk op}* $exponent (second parameter - defaults to e)
* *export* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ {section: export} - this routine will be exported by the current module by default

^^ "F"{link: Index} {section: F}

* *:f* _"(filetest op)"{link: [Perl 6 Lookup Tablet]Filetest Ops}_ {section: f filetest} - file is a plain file (no socket or dir, ...etc.)
* *:f* _"(quoting adverb)"{link: [Perl 6 Lookup Tablet]Quoting Adverbs}_ {section: f adverb} - demands evaluation of functions (subs and methods), that start with the *"&-sigil"{link: ampersand sigil}* and replacing them with the result, long form of *":function"{link: function adverb}* , included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *\F* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital F} - anything but form feed
* *\f* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash f} - form feed
* *fail* {section: fail} - causes the routine to return an unthrown exception, if _use fatal_ is in effect where the routine was called from, it throws the exception
* *Failure* _"(undefined value type)"{link: [Perl 6 lookup tablet] Undefined types}_ {section: Failure type} - data type object for an error, thrown by an unhandled exception
* *False* {section: false} - boolean value aka Bool::False, 0 in numeric context, {{''}} (empty) in string context
* *FatRat* _"(immutable type)"{link: [Perl 6 lookup tablet] immutable types}_ {section: fatrat type} - Perl rational (unlimited precision in both parts)
* *"ff"{link: [Perl 6 Operator tablet]flipflop}* {section: ff} - flip flop operator in the style of awk, formerly .. in scalar context
* *"fff"{link: [Perl 6 Operator tablet]flipflop}* {section: fff} - flip flop operator in the style of sed, formerly ... in scalar context
* *{{$?FILE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: file compiler var} - current filename of source file
* *FIRST* _"(closure trait)"{link: [Perl 6 lookup tablet]closure traits}_ {section: FIRST phaser} - marks a special block or statement, executed at loop initialization time, before any *"ENTER"{link: ENTER phaser}*
* *first* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: first} - 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 *"$_"{link: context var}* or $^a); works like *"grep"{link: grep}* - example : _{{first {$_ %% 2}, 1..5}}; # returns 2_
* *flat* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: flat} - forces flat list context, opposite of *"lol"{link: lol}* - example: _{{([2,3],[4,5]).flat or flat([2,3],[4,5]) results in: [2..5]}}_
* *flip* _(string method)_ {section: flip} - reverses order of characters in "string"{link: str type}, see also: *"reverse"{link: reverse}* and *"invert"{link: invert}*
* *"fmt"{link: [Perl 6 Basics tablet] fmt}* _(formater)_ {section: fmt} - variable method for simple *"printf"{link: printf}* - like formating, takes a format specifier and returns a "string"{link: 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);
* *"for"{link: [Perl 6 Block tablet] for}* _"(loop block modifier)"{link: [Perl 6 lookup tablet]Loops}_ {section: for} - only iterates over a list and sets *"$_"{link: context var}* for each iteration
* *"fork"{link: [Perl 6 IO Tablet] Processes}* {section: fork} - creates a copy of the current process and returns in the original process a Proc object of the child (0 in num context) and in the child a proc object of the original (process ID in num context)
* *from-radians* {section: from-radians} - convert from radians to $base (second parameter), opposite of *"to-radians"{link: to-radians}*
* *":function"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: function adverb} - demands evaluation of functions (subs and methods), that start with the *"&-sigil"{link: ampersand sigil}* and replacing them with the result, long form of *":f"{link: f adverb}* , included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* _Functional Programming_ {section: Functional Programming} - exclusively function based programming style, "strongly supported"{link: [Perl 6 Delta Tablet] Functional Programming} by Perl 6, considered as a branch of Declarative Programming

^^ "G"{link: Index} {section: G}

* *:g* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: g filetest} - report if file has setgid bit set
* *:g* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: g modifier} - searching for any finding (not just the first), short for *":global"{link: global modifier}*
* *|g* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: pipe g} - grapheme boundary, zero width space between two unicode graphemes, see also: *"|c"{link: pipe c}* and *"|w"{link: pipe w}*
* *gcd* _"(numeric infix op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: gcd} - greatest common divisor (see also: *"lcm"{link: lcm}*)
* *"gather"{link: [Perl 6 Block Tablet ]gather and take}* _(block modifier)_ {section: gather} - performs the following block once, returns a list of all values passed by *"take"{link: take}*
* *ge* _"(infix string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: ge}- greater than or equal, see also *"gt"{link: gt}* and *"le"{link: le}*
* *"get"{link: [Perl 6 IO tablet] get}* _(handle method)_ {section: get} - returns a line (item context) or all lines (list context) from that input stream like a file or "command line"{link: [Perl 6 IO tablet] Command Line}
* *"getc"{link: [Perl 6 IO tablet] getc}* _(handle method)_ {section: getc} - reads one character from a file via file handle
* *getlogin* {section: getlogin} - returns the username of the account running the program, maybe less secure as *"getpwuid"{link: getpwuid}*
* *gethost* {section: gethost} - establish a connection to a net host and retrieve information
* *{{$*GID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: gid global var} - real global ID of the running process (*"$*PID"{link: pid global var}*) owner, was @( and $GID in Perl 5
* *"given"{link: [Perl 6 Block tablet] given}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ {section: given} - case construct puts a value into the "context variable"{link: context var} for *"when"{link: when}* clauses
* *:global* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: global modifier} - searching for any finding (not just the first), long for *":g"{link: g modifier}*
* *"goto"{link: [Perl 6 Block tablet] goto}* _"(flow control)"{link: [Perl 6 lookup tablet]jump commands}_ {section: goto} - continue execution on a defined label (with "name:")
* *grab* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: grab} - 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"{link: pick}* ans *"roll"{link: roll}*
* *grabpair* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: grabpair} - random selection <n> (only parameter) of hash *"pairs"{link: pair}*, (each pair only once) , see also *"pick"{link: pick}* ans *"roll"{link: roll}*
* *grammar* {section: grammar} - special kind of *"class"{link: class}* with methods that execute *"regex"{link: regex}*, *"token"{link: token}* and *"rule"{link: rule}*
* *{{$?GRAMMAR}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: grammar compiler var} - grammar of the currently used language (mostly *"$~MAIN"{link: main var}*)
* *<graph>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: graph subrule} - a "graphical" character
* *:graphs* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: graphs modifier} - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
* *grep* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: grep} - 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 *"$_"{link: context var}* or $^a); see also *"first"{link: first}* - example : _{{grep {$_ %% 2}, 1..5}}; # returns 2 4_
* *gt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: gt} - "infix"{link: infix category} operator, greater than or equal, *"True"{link: true}* if alphabetically ordered the right comes before the left (see also *"lt"{link: lt}*, *"leg"{link: leg}* and *<*)

^^ "H"{link: Index} {section: H}

* *:h* _"(quoting adverb)"{link: [Perl 6 lookup Tablet]Quoting Adverbs}_ {section: h adverb} - demands evaluation of *"hash"{link: Hash}* variables that start with the *"%-sigil"{link: percent sigil}*, long form of *":hash"{link: hash adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *\H* _"(escape sequence)"{link: [Perl 6 lookup Tablet]Escape Sequences}_ {section: backslash capital H} - anything but horizontal whitespace char
* *\h* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash h} - horizontal whitespace char, part of *"\s"{link: backslash s}*
* *handles* {section: handles} - delegates execution of a function to another method
* *HardRoutine* - _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: hardroutine type} - A routine that is committed to not changing
* *has* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: has} - introduces attribute names, see also *"class"{link: class}*
* *Hash* _"(mutable type)"{link: [Perl 6 lookup tablet]Mutable types}_ {section: hash type} - Perl hash, a two column table of _Scalar_, values in one column are keys to refer to the values in the other column
* *hash* _"(context op)"{link: [Perl 6 lookup tablet]Contextualizers}_ {section: hash} - enforces hash-list context, alias to *"%()"{link: percent op}*
* *":hash"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: hash adverb} - demands evaluation of hash variables that start with the *"%-sigil"{link: percent sigil}*, long form of *":h"{link: h adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *":heredoc"{link: [Perl 6 basics tablet]Heredocs}* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: heredoc adverb} - defines end marker for the following heredoc, *:heredoc* is equal to *":to"{link: to adverb}*
* *HOW* _"(introspection method)"{link: [Perl 6 lookup tablet]object introspection}_ {section: how introspection } - (reserved for documentation)
* *hyper* {section: hyper} - forces none-lazy list context, that ignores the order of results (allowes parallel computing)

^^ "I"{link: Index} {section: I}

* *:i* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: i modifier} - uppercase and lowercase variants of a letter are taken as the same letter, short for *":ignorecase"{link: ignorecase modifier}* (same as in Perl 5)
* *"if"{link: [Perl 6 Block tablet] if}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ {section: if} - flow control conditional statement or block modifier, executes following code block only when a condition expression evaluates to *"True"{link: true}* (see also *"elsif"{link: elsif}* and *"else"{link: else}*)
* *:ignorecase* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ignorecase modifier} - uppercase and lowercase variants of a letter are taken as the same letter, long for *":i"{link: i modifier}* (same as in Perl 5)
* *:ignoremark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ignoremark modifier} - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, long for *":m"{link: m modifier}*
* *:ii* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ii modifier}- only for substitutions, replacing with chars that have the same case pattern as the replaced, short for *":samecase"{link: samecase modifier}*
* *"import"{link: [Perl 6 Subroutine tablet] }* {section: import} - just import definitions from an already loaded module (see *"use"{link: use}* and *"need"{link: need}*)
* *{{$*IN}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: in global var} - standard input (command line mostly), see also *"$*OUT"{link: out global var}*
* *{{@*INC}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: inc global var} - include pathes (but not for standard library modules), formerly @INC
* *index* _(string method)_ {section: index} - finds the first occurrence of a substring in a string and returns the numerical position, opposite or _rindex_
* *Inf* {section: Inf} - infinity, to generate infinite lazy lists, does same as *"*"{link: asterisk op}*
* *infix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix category} - namespace of symbols that stay between two statements, that become their parameters - example: _{{$a + $b # is same as $a.&infix:<+>($b)}}_
* *infix_circumfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_circumfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "circumfix"{link: circumfix category} other operator but stay "infix"{link: infix category} (between) two terms (mostly lists) - example (the arrows): _ @a <<+<< @b_
* *infix_postfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_postfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "postfix"{link: postfix category} other operator but stay "infix"{link: infix category} (between) two terms - example (equal sign): _ $a += 5_
* *infix_prefix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_circumfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "prefix"{link: prefix category} (precedes) other operator but stay "infix"{link: infix category} (between) two terms - example (exclamation mark): _ 4 != 5_
* *INIT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: INIT phaser} - marks a special block or statement, executed at run time, ASAP, only ever runs once
* *inline* _(sub trait)_ {section: inline} -
* *Instant* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: instant type} - a point on the continuous atomic timeline
* *Int* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: int type} - Perl integer (allows Inf/NaN, arbitrary precision, etc.); use it as method to convert into a int like the Perl 5 "int"
* *invert* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: invert} - inverts the key => value relation of a pair or a series of pairs (hash), returning a *"Pair"{link: Pair}* *"list"{link: list}*, see also *"reverse"{link: reverse}* and *"flip"{link: flip}*
* *IO* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: io type} - Perl filehandle
* *is* {section: is} - bind a traits to a variable
* *item()* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: item} - forces scalar context, alias to *"$()"{link: dollar op}*
* _Iteration_ {section: iteration} - flow control, repeatedly executing a block
* *Iterator* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: iterator type} - Perl list

^^ "J"{link: Index} {section: J}

* *join* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: join} - concatenates list elements into a string, optionally inserting another string between the elements - example: _{{join("-", 1..5) # returns '1-2-3-4-5' - or (1..5).join("-")}}_

^^ "K"{link: Index} {section: K}

* *:k* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: k filetest} - report if file has sticky bit set
* *KEEP* _"(closure trait)"{link: [Perl 6 lookup tablet]Closure traits}_ {section: KEEP phaser} - marks a special block, executed at every successful block exit, part of *"LEAVE"{link: LEAVE phaser}* queue
* *:keepall* _"(regex modifier)"{link: [Perl 6 Lookup tablet]Regex Modifier}_ {section: keepall modifier} - forces subrules to memorize everything (even comments)
* *{{$*KERNEL}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: kernel global var} - (core or type of the) running operating system, use _$KERNEL.name_ instead of Perl 5 $OSNAME, see also: *"$*DISTRO"{link: distro global var}* and *"$*VM"{link: vm global var}*
* *{{$?KERNEL}}*_"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: kernel compiler var} - kernel (core operating system) the program was compiled for, might want to use use _$?KERNEL.name_, see also: *"?*DISTRO"{link: distro compiler var}* and *"$?VM"{link: vm compiler var}*
* *key* _"(pair method)"{link: [Perl 6 Variable Tablet]Pair}_ {section: key} - gives the key part of a pair, opposite of *"value"{link: value}*
* *KeyBag* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ {section: KeyBag type} - KeyHash of UInt (does Bag in list/array context)
* *KeySet* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ {section: KeySet type} - KeyHash of *"Bool"{link: Bool type}* (does Set in list/array context)
* *keys* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: array keys} - returns the list array indexes
* *keys* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: keys} - returns list of hash keys
* *"kill"{link: [Perl 6 IO Tablet] Processes}* {section: kill} - sends the given $signal to the process(es) given and returns a boolean value indicating success (*"True"{link: true}*)
* *kv* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: kv} - returns list of key-value pairs

^^ "L"{link: Index} {section: L}

* *:l* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: l filetest} - file is a symbolic link
* *\L[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet]Escape Sequences}_ {section: backslash capital L} - everything within the brackets is lowercase
* *{{$*LANG}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: lang global var} - LANG variable from *"%*ENV"{link: env global var}* that defines what human language is used
* *LAST* _"(closure trait)"{link: [Perl 6 lookup tablet] closure traits}_ {section: LAST phaser} - marks a special block, executed at loop termination time, after any *"LEAVE"{link: LEAVE phaser}*
* *last* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: last} - exit the current looping block
* *last* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: last} - number of final element
* *lazy* - forces lazy evaluation (calculate values as late as possible), default for lists {section: lazy} - not scalars
* *lc* _(string op & method)_ {section: lc} {section: lc} - make string lowercase
* *lcfirst* _(string op & method)_ {section: lcfirst} - make first char of a string lowercase
* *lcm* _"(numeric infix op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: lcm} - least common multiple, see also: *"gcd"{link: gcd}*
* *le* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: le} - "infix"{link: infix category} operator, result is *"True"{link: true}* if left side is lower than or equal than the right, see also: *"lt"{link: lt}*, *"gt"{link: gt}* and *"ge"{link: ge}*
* *LEAVE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: LEAVE phaser} - marks a special block, executed at every block exit time
* *"leave"{link: [Perl 6 Block tablet] leave}* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: leave} - exit the current block with a return value
* *leg* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: leg} - general "infix"{link: infix category} sort comparison operator in "string context"{link: string context}, leg stands for lower/equal/greater, *"cmp"{link: cmp}* is the more general form, *"<=>"{link: spaceship op}* does same in "numerical context"{link: numerical context}, was cmp in P5
* *let* {section: let} - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully
* *{{$?LINE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: line compiler var} - current line number
* *"lines"{link: [Perl 6 Basics tablet] }* _(string & iomethod)_ {section: lines} - returns a chomped list of lines (chunks of character separated by *"\n"{link: backslash n}*) containing a string - example: {{ $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit ) }}, works also on file handles
* *list()* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: list} - almost a no-op, just makes sure that $item (first parameter) can be iterated, alias to *"@()"{link: at op}*, see also *"flat"{link: flat}* and *"lol"{link: lol}*
* _list context_ -
* *"log"{link: [perl 6 Operator tablet]}* {section: log} - logarithm of $x (first parameter) to the $base (second optional parameter - default is _e_, together also known as _ln_ )
* *"log10"{link: [perl 6 Operator tablet]}* {section: log10} - logarithm to the base of 10, also known as lg on calculators
* *lol* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: lol} - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of *"flat"{link: flat}*
* _longest token matching_ {section: longest token matching} - (short _LTM_) when searching a pattern with alternatives (sub|substr) the search will continue after finding the pattern 'sub' because of looking for the longest alternative
* *"loop"{link: [Perl 6 Block tablet] loop}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: loop} - general flow control command for repetition
* *looser* _"(routine trait)"{link: [Perl 6 lookup tablet]Routine Traits}_ {section: looser} - specifies the "precedence of an operator"{link: [perl 6 lookup tablet] table of precedence} lower than an existing operator
* *<lower>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: lower subrule} - a single lowercase character
* *lt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: lt} - "infix"{link: infix category} operator, lower than, *"True"{link: true}* if alphabetically ordered the left comes before the right

^^ "M"{link: Index} {section: M}

* *"m//"{link: [Perl 6 Regex Tablet] Matching}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: m op} - perform a regex based search in place (m stands for _match_ ), similar to *"match"{link: match}*-method
* *:m* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: m modifier} - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for *":ignoremark"{link: ignoremark modifier}*
* *Macro* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: macro type} - Perl compile-time subroutine
* *macro* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: macro} - define a routine to alter source code at compile time
* *{{$~MAIN}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: main var} - current "grammar"{link: grammar} of main language, tells the parser the rules of parsing Perl
* *map* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: map} - take a list, perform a block on each member, return a list of the results - example: _{{say map { chr $_ }, 66..69}}_ (is "B C D E") or _{{say map { chr $_ }, 66..69}}_
* *Match* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: macth type} - Perl match object, usually produced by applying a pattern of _"regular expression"{link: regular expression}_ to a string
* *match* _(string method)_ {section: match} - method alias to *"m/.../"{link: m op}*, $str.match( /<p>/ ) equals $str ~~ m/<p>/;, returns a match object that end up also in *"$/"{link: match var}*
* *max* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: max} - returns the numerically largest value from a given list
* *maybe* _(block modifier)_ {section: maybe} -
* _"metaoperator"{link: [perl 6 lookup tablet] metaoperators}_ {section: metaoperator} - alters the meaning of other operators
* *Method* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: method type} - Perl method
* *method* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: method} - defines a method (inheritable routine) in a class
* *min* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: min} - returns the numerically smallest value from a given list
* *minmax* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: minmax} - returns the highest and lowest values from a list, as a 2 item list
* *:mm* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: mm modifier} - substitute with chars that has same mark/accent pattern as the matched string, short for *":samemark"{link: samemark modifier}*
* *"mkdir"{link: [Perl 6 IO tablet] mkdir}* {section: mkdir} - creates a directory with given name
* *mod* _(numeric op)_ {section: mod} - integer modulo operator; wordy alias to *"%"{link: percent}* - example: _5 mod 4 = 1;_
* *module* _(block modifier)_ {section: module} - introduces a module name, a package that performs special actions on loading
* *{{&?MODULE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: module compiler var} - reference to the current module
* *"ms//"{link: [Perl 6 Regex Tablet] Matching}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: ms op} - perform a regex based search in place, spaces are just subrule separators, alias to *m:s/.../* or *m* *":sigspace"{link: sigspace modifier}* */.../*
* *Mu* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Mu type} - most (generic) undefined object
* *multi* _"(routine modifier)"{link: [perl 6 lookup tablet] Routine Modifier}_ {section: multi} - marks routines with can have sibling with same name but different _"signature"{link: signature}_, when called, the one with matching sig is executed (multimethod dispatch)
* *my* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: my} - introduces lexically scoped names, which exists only in the current scope (usually a block)

^^ "N"{link: Index} {section: N}

* *\N* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital N} - anything but (logical) newline
* *\n* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash n} - (logical) newline
* <n> *:nd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: nd modifier} - demands the nth finding (:2nd), has many aliases (*:st* *:rd* *:th*) for correct spelling
* *name* _(routine method)_ {section: name} - returns the name of of a routine, handy when it was stored in a scalar
* *"need"{link: [Perl 6 Subroutine tablet] }* {section: need} - just load a module, without import definitions (see *"use"{link: use}* and *"import"{link: import}*)
* *new* {section: new} - creates a new object of a class(as in most other languages), also name of the automatically called constructor method
* *NEXT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: NEXT phaser} - marks a special block, executed at loop continuation time, before any *"leave"{link: LEAVE phaser}*
* *next* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: next} - start the the next following loop iteration
* *nextsame* {section: nextsame} - get from the dispatcher the next candidate with the same _"signature"{link: signature}_, similar to javas SUPER
* *Nil* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: nil type} - unlike _undef_ in Perl 5 it really means no value here - example: _@a = Nil, Nil; # array has zero elements_
* *none* _(junctive op)_ {section: none} - return *"True"{link: true}* when a value is not part of a set, junctive _NOT_ operator
* *normalize* - _(string method)_ {section: normalize} - normalize (repair) Unicode (UTF) string
* *not* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ {section: not} - logical _NOT_ operator, returns *"False"{link: false}* if value is positive or *"True"{link: true}* if negates, low precedence version of *!*
* *"note"{link: [Perl 6 IO tablet] note}* {section: note} - makes output via command line ($ERR) like *"warn"{link: warn}*, but appends a newline (*"\n"{link: backslash n}*) like *"say"{link: say}*
* *Num* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Num type} - Perl number (approximate Real, generally via floating point)
* *numerator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: numerator} - returns the numerator of a rational number (value type Rat and FatRat)

^^ "O"{link: Index} {section: O}

* *:O* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital O filetest} - tests if file is owned by real uid
* *:o* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: o filetest} - tests if file is owned by effective uid
* _Object Oriented Programming_ {section: object oriented programming} - programming paradigm (style), that arranges data and functions that belong together into so called objects
* *of* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: of} - inner type constraint that a routine imposes on its return value - example: _subset Month of Int where { 1 <= $^a <= 12 }_
* *one* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: one} - junctive _XOR_ operator, *"True"{link: true}* if only one expression (of a following list) is true in bool context, see also: *"|"{link: junctive xor}*
* *only* _"routine modifier"{link: [perl 6 lookup tablet] routine modifier}_ {section: only} - permits only one routine of the same name in this block
* *"open"{link: [Perl 6 IO tablet] open}* _(path method)_ {section: open} - establishes a connection to a file via a file path name file handler
* *or* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: or} - short circuit _OR_, "evaluates"{link: evaluation} sequentially, ends evaluation at the first expression that returns *"True"{link: true}*, low precedence version of *"||"{link: high or}*, similar to *"orelse"{link: orelse}*
* *ord* _(string method)_ {section: ord} - convert charakter into number according a character table, reverse of _char_
* *orelse* _(logical op)_ {section: orelse} - logical _OR_ short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to *"//"{link: high err}*, see also *"andthen"{link: andthen}*
* *our* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: our} - introduces *"package"{link: package}* - scoped names for variables and routines
* *{{$*OUT}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: out global var} - standard output (command line mostly), see also *"$*IN"{link: in global var}*
* *:ov* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ov modifier} - searching at all positions just one time (with backtracking), short for *:overlap*
* *:overlap* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: overlap modifier} - searching at all positions just one time (with backtracking), long for *:ov*

^^ "P"{link: Index} {section: P}

* *:p* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: p filetest} - file is a named pipe (FIFO), or filehandle is a pipe
* *":p"{link: [Perl 6 Basics tablet] Paths}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: p adverb} - quote paths and create path object that know the right format of the current *"$*KERNEL"{link: kernel global var}* with *{{Q :p /.../}}*, short for *":path"{link: path adverb}*
* *:p*(<n>) _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: p modifier} - searching only on the nth (n is an int) position (counting from 0), short for *":pos"{link: pos modifier}*
* *:P5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: P5 modifier} - activate old Perl 5 regex rules, alias to *":Perl5"{link: Perl5 modifier}*
* *{{$~P5Regex}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: p5regex var} - current "grammar"{link: grammar} of the Perl 5 compatible regular expression language
* *"pack"{link: [Perl 6 Basics tablet] pack}* {section: pack} - repackage values into or from a condensed format
* *package* _(block modifier)_ {section: package} - defines this Block or File as namespace (almost like in Perl 5), some uses are now better to do with *"module"{link: module}* and *"class"{link: class}*
* *{{&?PACKAGE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: package compiler var} - reference to the current package
* *package_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: package_declarator category} - internal namespace for - example: _"package"{link: package}, "module"{link: module}, "class"{link: class}_
* *Pair* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Pair type} - A single key-to-value association
* *pair* _(context op)_ {section: pair} - force pair context
* *pairs* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: pairs} - returns all contents as an array or pairs (key,value)
* *PairSeq* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: PairSeq type} - A *"Seq"{link: Seq}* of *"Pairs"{link: Pair}*
* *:panic* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: panic modifier} - overwriting a possible set *":ratchet"{link: ratchet modifier}* for all subrules (activates backtracking)
* _parameter_ {section: parameter} - value passed to a method or subroutine, mostly as part of the signature
* *Parcel* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Parcel type} - Arguments in a comma list
* *parcel* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: parcel} - raw reference, will not be contextualized
* *parsed* _"(routine trait)"{link: [perl 6 lookup tablet]routine traits}_ {section: parsed} - this macro will be parsed once, it is hygienic, but own and later defined rules can't be applied, opposite of *"reparsed"{link: reparsed}*
* _parsetree_ {section: parsetree} - hierarchical data representing the logical structure of a program, also called _"AST"{link: AST}_
* *":path"{link: [Perl 6 Basics tablet] Paths}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: path adverb} - quote paths and create path object that know the right format of the current *"$*KERNEL"{link: kernel global var}* with *{{Q :path /.../}}*, long for *":p"{link: p adverb}*
* *"perl"{link: [Perl 6 Basics tablet] perl}* _(formater)_ {section: perl} - transforms data structure into Perl 6 source syntax; use *"eval"{link: eval}* onto that string and you get the data structure again; bit like _Data::Dump_
* *{{$*PERL}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: perl global var} - Perl version running under, was $] and $^V in Perl 5
* *{{$?PERL}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: perl compiler var} - Perl version compiled for
* *:Perl5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: Perl5 modifier} - activate old Perl 5 regex rules, alias to *":P5"{link: P5 modifier}*
* *pick* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pick} - select a number (first parameter) of random vaues (without duplication), take *"roll"{link: roll}* to enable duplication
* *{{$*PID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: pid global var} - ID of the running process, was $$ and $PID in Perl 5
* "phaser"{link: [perl_6_lookup_tablet] closure traits} {section: phaser} - Perl 6 term for specially named subblocks withe special runtimes aka closure traits - example: *"BEGIN"{link: BEGIN phaser}*
* *pick* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pick} - selects randomly elements from this list, optional parameter says how many
* _pipe_ {section: pipe} - connection between 2 processes, move data (mostly only in one direction) without buffering
* _"POD"{link: [perl 6 basics tablet] pod}_ {section: POD} - Plain Old Documentation, a markup language to be embedded into Perl source code, has in Perl 6 ability to store data to be retrieved later
* *{{$=pod}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: pod pod var} - surrounding _"POD"{link: POD}_ object
* _pointy block_ {section: pointy block} - a block that is given parameters with *"->"{link: arrow op}*
* *polar* {section: polar} - magnitude or angle corresponding to the complex number(only parameter); the magnitude is non-negative, and the angle in the "range"{link: range op} {-π ..^ π}}
* *pop* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pop} - removes and returns the last element in an array
* *:pos*(<n>) _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: pos modifier} - searching only on the nth (n is an int) position (counting from 0), long for *":p"{link: p modifier}*
* *POST* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: POST phaser} - marks a special block, assert postcondition, executed at every block exit, after *"LEAVE"{link: LEAVE phaser}*
* *postcircumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postcircumfix category} - operator namespace of ops, that stay after one statement or variable, but do surround a second - example(square brackets): _$a[2]_
* *postfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postfix category} - operator namespace of ops, that stay after a statement or variable (like $a++)
* *postfix_prefix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postfix_prefix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "prefix"{link: prefix category} (precedes) other operator but stay "postfix"{link: postfix category} (after) another term - example (greater as): _@a >>++_
* *PRE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: PRE phaser} - marks a special block, assert precondition, executed at every block entry, before *"ENTER"{link: ENTER phaser}*
* *pred* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: pred} - returns the predecessor of $x (only parameter), alias to *--* operator, see also *"succ"{link: succ}*
* *prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix category} - operator namespace of ops, that stay before a statement or variable - example: _"++$a"{link: plus plus}_
* *prefix_circumfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix_circumfix_meta_operator} - internal namespace of "metaoperator"{link: metaoperator} that "circumfix"{link: circumfix category} (surrounds) other operator but stay "prefix"{link: prefix category} (before) another term - example (square brackets): _{{[+] @a # sums up all elements of @a}}_
* *prefix_postfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix_postfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "postfix"{link: postfix category} other operator but stay "prefix"{link: prefix category} (before) another term - example (greater as): _++<< @a_
* *"pretty"{link: [Perl 6 Basics tablet] pretty}* _(formater)_ {section: pretty} - format data structures, optimized for human interpretation
* *"print"{link: [Perl 6 IO tablet] print}* {section: print} - sends characters to an output stream (*"$*OUT"{link: out global var}*) without adding a newline, similar to *"say"{link: say}*
* *"print"{link: [Perl 6 IO tablet] print for files}* _(handle method)_ {section: print io} - writes a stream into a file
* *<print>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: print subrule} - a single printable character
* *"printf"{link: [Perl 6 IO tablet] printf}* {section: printf} - formats text like *"sprintf"{link: sprintf}* and sends it to standard output like *"print"{link: print}*
* *"<prior>"{link: [Perl 6 Lookup tablet] subrules}* {section: prior subrule} - standard grammar's rule for whatever the prior successful regex matched
* *"prompt"{link: [Perl 6 IO tablet] prompt}* {section: prompt} - *"print"{link: print}* - ing text and reading the answer (a line from *"$*IN"{link: in global var}* - formerly _STDIN_)
* _property_ {section: property} - metadata of a variable set at runtime
* *proto* _"(routine modifier)"{link: [perl 6 lookup tablet] routine modifier}_ {section: proto} - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed
* *<punct>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: punct subrule} - a single punctuation character
* *push* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: push} - appends a list of values to the end of an array (see also *"pop"{link: pop}*)
* *push* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ - inserts a list of "pairs"{link: Pair} in a Hash; if a key already exists, it will point to an array of both values

^^ "Q"{link: Index} {section: Q}

* *"Q"{link: [Perl 6 Basics tablet] Quoting}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: capital Q op} - most basic quoting operator, understands a list of "adverbial modifier"{link: [perl_6_lookup_tablet] Quoting Adverbs}
* *"q"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: q op} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *Q :q /.../* and *Q ":single"{link: single adverb} /.../*
* *":q"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: q adverb} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *q /.../*, short for *":single"{link: single adverb}*
* *\Q[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital Q} - all metacharacters within the brackets match as literal characters
* *{{$~Q}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: q var} - current "grammar"{link: grammar} of the quoting language
* *"qp"{link: [Perl 6 Basics tablet] Paths}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qp op} - path quoting, quoted string will be evaled as an file or directory path, alias to *Q ":p"{link: p adverb} /.../* and *Q ":path"{link: path adverb} /.../*
* *"qq"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qq op} - _double quoting_, *q* with interpolation of variables, closures, and special chars, alias to *""...""{link: double quotation marks}* and *Q :s, :a, :h, :f, :c, :b /.../* and *Q* *":qq"{link: qq adverb}* */.../* and *Q* *":double"{link: double averb}* */.../*
* *":qq"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: qq adverb} - _double quoting_, *q* with interpolation of variables and "blocks"{link: block}, alias to *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *Q :s, :a, :h, :f, :c, :b /.../*, short for *":double"{link: double adverb}*
* *"qqx"{link: [Perl 6 basics tablet]Code}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qqx op} - run as system call and return results; was _qx/.../_ in Perl 5
* *quasi* _(block modifier)_ {section: quasi} - quasi quoting, the following commented will be compiles and the AST will be returned as result, see also: code
* *{{$~Quasi}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: quasi var} - current "grammar"{link: grammar} of the quasiquoting language
* *quote* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: quote category} - operator namespace, used to define new quoting ops with a macro
* *quote_mod* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: quote mod category} - operator namespace, used to define new quoting adverbs
* *":quotewords"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: quotewords adverb} - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and *""...""{link: double quotation marks}* sourrounded strings are taken as single words), long form of *":ww"{link: ww adverb}*, used in *"<<...>>"{link: double angle brackets}*
* *"qw"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qw op} - splits result on words (as in Perl 5); alias to *Q :q :w /.../* or *"<...>"{link: angle brackets}*
* *"qx"{link: [Perl 6 basics tablet]Code}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qx op} - evaluate as Perl term (like *"eval"{link: eval}*) and return results (unlike Perl 5), alias to *Q ":x"{link: x adverb} /.../* or *Q ":exec"{link: exec adverb} /.../*

^^ "R"{link: Index} {section: R}

* *:R* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital R filetest} - check if file is readable by real uid/gid
* *:r* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: r filetest} - check if file is readable by effective uid/gid
* *\R* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital R} - anything but return
* *\r* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash r} - return (CR), as in Perl 5
* *R*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: capital r metaop} - reverse operands
* *rand* {section: rand} - pseudo random number in "range"{link: range op} _0 ..^ 1_ (including 0, but not 1); for random list choices see *"pick"{link: pick}* and *"roll"{link: roll}*
* *Range* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: range type} - a pair of ordered endpoints, result of an evaluated term with the "range operator"{link: range op}
* *RangeIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: rangeiter type} - Iterator over a *Range*
* *Rat* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: rat type} - Perl rational number (exact *"Real"{link: real type}* numerator, limited denominator)
* *:ratchet* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ratchet modifier} - deactivates backtracking, search starts at pos, where last match ended
* <n> *:rd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: rd modifier} - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd)
* *"read"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: read} - read n (first parameter) bytes from a buffer
* *"readline"{link: [Perl 6 IO tablet] readline}* {section: readline} -
* *readonly* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: readonly} - immutable parameter
* *redo* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: redo} - re-starts processing of the current loop turn
* *reduce* _(list method)_ {section: reduce} - alias to *"[ ]"{link: square bracket metaop}* "metaoperator"{link: [perl 6 lookup tablet] metaoperators}: _{{ [+] @a = @a.reduce(&[+]) }}_
* _reference_ {section: reference} - address of data in memory, often termed a Capture in Perl 6
* *Regex* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Regex type} - builtin type that holds a compiled regular expression
* *regex* - _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: regex} - a pattern definition (without *":ratchet"{link: ratchet modifier}* and *":sigspace"{link: sigspace modifier}*), can be put in a *"grammar"{link: grammar}*, similar to qr/.../ in Perl 5, see *"rule"{link: rule}*, *"token"{link: token}*
* *":regex"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: regex adverb} - parse as quoted string as regex
* *{{$~Regex}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: regex var} - current "grammar"{link: grammar} of the regex language, tells the parser how to parse regular expressions
* _regular expression_ {section: regular expression} - in Perl5: pattern matching notation, either regex, token or rule in Perl6
* *reparsed* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: reparsed} - after parsing this *"macro"{link: macro}*, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of *"parsed"{link: parsed}*
* *"repeat"{link: [Perl 6 Block tablet] repeat}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: repeat} - initial command for *"while"{link: while}* or *"until"{link: until}* loops that have their condition at the end
* *"rename"{link: [Perl 6 IO tablet] rename}* {section: rename} - changes names of files and directories
* *return* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: return} - leaves a subroutine and sets the return value
* *returns* {section: returns} - sub trait describing the type of value produced by a function
* *reverse* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: reverse} - returns all the members in the opposite order. Use *"flip"{link: flip}* to turn a string back to front and *"invert"{link: invert}* for hashes
* *rindex* _(string method)_ {section: rindex} - finds the last occurrence of a substring in a string and returns the numerical position, opposite or *"index"{link: index}*
* *"rmdir"{link: [Perl 6 IO tablet] rmdir}* {section: rmdir} - deletes a directory with given name
* *role* {section: role} - container for methods that can extend a class using *"does"{link: does}*
* *{{$?ROLE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: role compiler var} - current role object
* *{{::?ROLE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: role package compiler var} - name of the current role
* *roll* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: roll} - selects <n> (first parameter) values from an array, duplication can occur (like rolling dice), *"pick"{link: pick}* works without duplication
* *roots* {section: roots} - (Num $f, Int $n) compute the $n'th root of $f
* *"rotate"{link: [Perl 6 Variable Tablet]}* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: rotate} - put some elements (number is first parameter) of a list to the end; rotates backward with negative parameter; _{{@a .= rotate;_ is alias to _@a.push: @a.shift;}}_
* *round* {section: round} - returns the nearest integer of only parameter
* *roundrobin* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: roundrobin} - kind of *"zip"{link: zip}* that ignores empty lists - example: _{{roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3}}_
* *{{&?ROUTINE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: routine compiler var} - current routine object
* *Routine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: routine type} - base class for all "wrappable"{link: wrap} executable objects libs *"sub"{link: sub}*, *"method"{link: method}* and alike
* *routine* {section: routine} -
* *routine_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: routine_declarator category} - internal namespace for "routine declarators"{link: [perl_6_lookup_tablet]Routine Types} - example: _"sub"{link: sub}, "method"{link: method}_
* *rule* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: rule} - alias for _*"regex"{link: regex}* *":ratchet"{link: ratchet modifier}* *":sigspace"{link: sigspace modifier}*_ in a grammar, see *"regex"{link: regex}*, *"token"{link: token}*
* *"run"{link: [Perl 6 IO Tablet] Processes}* {section: run} - executes an external program, and returns control to the caller once the program has exited
* *"runinstead"{link: [Perl 6 IO Tablet] Processes}* {section: runinstead} - executes an external program that replaces the caller, because there will be no return
* _runtime_ {section: runtime} - time when software is being used (not compiletime), or software components necessary for that, or length of time to execute
* *rw* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: rw routine trait} - marks a subroutine as returning an lvalue
* *rw* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: rw parameter trait} - mutable parameter (rw stands for: read write)
* *:rw* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: rw modifier} - gives the regex the right to change the string (operand)
* *"rx"{link: [Perl 6 Regex Tablet] Regex Operators}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: rx} - creates anonymous regex, that can me then assigned into a var, alias to *"Q"{link: capital Q op}* *":regex"{link: regex adverb}* */.../* and *"regex"{link: regex}* _(routine type)_

^^ "S"{link: Index} {section: S}

* *S*<op> _"(meta op)"{link: [Perl 6 lookup tablet] Metaoperators}_ {section: S} - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism
* *"s///"{link: [Perl 6 Regex Tablet] Regex Operators}* _"(regex quoting op)"{link: [Perl 6 lookup tablet] Quoting Ops}_ {section: s op} - perform a substitution based on rx-matches in place, creates anonymous regex, alias to *Q :subst /.../.../* and *".subst()"{link: subst}* _(string method)_
* *:S* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ {section: capital S filetest} - file is a socket
* *:s* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ {section: S filetest} - file has size greater than 0 (zero)
* *:s* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: s adverb} - demands evaluation of scalar variables that start with the *"$-sigil"{link: dollar sigil}*, long form of *":scalar"{link: scalar adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* *:s* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: s modifier} - whitespace separates now subregex and don't stand for spaces to look for, short for *":sigspace"{link: sigspace modifier}*, *"ms/.../"{link: ms op}* is alias to *m:sigspace/.../*
* *\S* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital S} - anything but whitespace
* *\s* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash s} - any whitespace character, horizontal ( *"\h"{link: backslash h}* ) and vertical ( *"\v"{link: backslash v}* )
* *<?same>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: same subrule} - match the zero-width space between two identical chars
* *:samecase* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: samecase modifier} - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for *":ii"{link: ii modifier}*
* *:samemark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: samemark modifier} - substitute with chars that has same mark/accent pattern as the matched string, long for ":mm"
* *:samespace* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: samespace modifier} - smart space mapping for substitutions, long for *":ss"{link: ss modifier}*, *"ss/.../.../"{link: ss op}* is alias to *s:samespace/.../.../* - example: _ss/teh hsa/the has/;_
* *"say"{link: [Perl 6 IO tablet] say}* {section: say} - makes output via command line (*"$*OUT"{link: out global var}*) like *"print"{link: print}*, but appends a newline (*"\n"{link: backslash n}*)
* *"say"{link: [Perl 6 IO tablet] say for files}* _(handle method)_ {section: say io} - writes a stream into a file and appends *"\n"{link: backslash n}*
* *Scalar* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: scalar type} - object to hold a Perl scalar, a variable for a single value
* *":scalar"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: scalar adverb} - demands evaluation of scalar variables that start with the *"$-sigil"{link: dollar sigil}*, long form of *":s"{link: s adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}*
* _scope_ {section: scope} - the block of code within which an identifier is usable
* *scope_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: scope_declarator category} - internal namespace for "scope declarators"{link: [perl_6_lookup_tablet]Scope Declarator} - example: _"my"{link: my}, "our"{link: our}, "has"{link: has}, "state"{link: state}_
* *seed* {section: seed} - initialize a random number generator, optionally with a value
* *Seq* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Seq type} - A list of values (can be generated lazily)
* *SeqIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: SeqIter type} - Iterator over a Seq
* *Set* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Set type} - unordered collection of values that allows no duplicates
* *set* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: set} - creates a Set
* *sigil* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: sigil category} - word to name the namespace for sigils, used to redifine them or define your own with a macro
* _sigil_ {section: sigil} - character that serves as a prefix to categorize the following name, most prominent in Perl are the variable "sigils"{link: [perl 6 lookup tablet] Sigils}: *"$"{link: dollar sigil}*, *"@"{link: at sigil}* and *"%"{link: percent sigil}*
* *sign* {section: sign} - 1 when $x (only parameter) > 0, -1 if < 0, 0 when = 0, undefined when undefined
* *Signature* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: signature type} - object type to hold all information a signature like parameter types and values, return type, etc.
* *signature* _(routine method)_ {section: signature} - returns a capture object with the signature of this routine
* *signature* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: signature routine trait} - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type
* _signature_ {section: signature} - function parameters (left-hand side of a binding), surrounded by round parentheses
* *:sigspace* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: sigspace modifier} - whitespace separates now subregex and don't stand for spaces to look for, long for for *":s"{link: s modifier}*, *"ms/.../"{link: ms op}* is alias to *m:sigspace/.../*
* *"sin"{link: [Perl 6 Operator Tablet]}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: sin} - sine, trigonometric function, takes angle in radian; see also *"to-radians"{link: to-radians}*, *"cos"{link: cos}*, *"tan"{link: tan}*
* *":single"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: single adverb} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *"q/.../"{link: q op}*, long for *":q"{link: q adverb}*
* *sleep* {section: sleep} - attempt to sleep for up to Num $for seconds (with sub-second resolution)
* _slice_ {section: slice} - part of an array or list
* *slang* {section: slang} - sublanguages of Perl 6, their grammar is mostly stored in "special variables"{link: [perl 6 lookup tablet] Special Variables} with the "twigil"{link: twigil} ~, such as *"$~Regex"{link: regex var}* or *"$~MAIN"{link: main var}* (main language); you can change or alter them with this keyword by using the _augment_ or _supersede_ command
* *"slurp"{link: [Perl 6 Basics tablet] Files}* _(path|file handle method)_ {section: slurp} - reads an entire file into a string without a file handle
* _slurpy array_ {section: slurpy array} - array parameter that receives all (slurps) all optional subroutine arguments
* *so* _(op)_ {section: so op} - converts value into the boolean context, low precedence alternative to *"?"{link: question mark op}*
* *SoftRoutine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: softroutine type} - A routine that is committed to staying mutable
* *<space>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: space subrule} - single white space char aka *"\s"{link: backslash s}*
* *special_variable* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: special_variable category} - namespace to define and redefine "special variables"{link: [perl 6 lookup tablet] Special Variables} with a macro
* *splice* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: splice} - remove on $pos (first parameter) $n (second - optional) values and replace them with values (third - optional)
* *split* {section: split} - makes an array of substrings from a string and a separator
* *"sprintf"{link: [Perl 6 Basics tablet] sprintf}* _(formater)_ {section: sprintf} - inserts formated values out of variables into a string like *"printf"{link: printf}*, but returns the string instead of outputting it
* *sqrt* {section: sqrt} - square root of $n (Num - first and only parameter)
* *"ss///"{link: [Perl 6 Regex Tablet] Substitution}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: ss op} - performs *"rx"{link: rx}* based substitution, spaces are just subrule separators, alias to *s:ss/.../.../*, e.g.: ss/teh hsa/the has/;
* *:ss* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ss modifier} - only for for substitution, whitespace separates subregexes like *":sigspace"{link: sigspace modifier}*, but also in the second part, short for *":samespace"{link: samespace modifier}*
* <n> *:st* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: st modifier} - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st)
* *START* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: START phaser} - marks a special block or statement, executed on first ever execution, once per closure clone
* *Stash* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: stash type} - A symbol table hash (package, module, class, lexpad, etc)
* *stat* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: stat} - available information about a file or link (call _stat :link_ as former lstat)
* *state* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: state} - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)
* *statement_control* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_control category} - internal namespace for block modifier like "conditionals"{link: [perl 6 lookup tablet]Conditionals} or "loops"{link: [perl 6 lookup tablet]Loops} that stay in front of it
* *statement_mod_cond* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_mod_cond category} - internal namespace for words that come after a statement and handle if the statement will be executed - example : _*$a++ "if"{link: if}* $a > 3_
* *statement_mod_loop* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_mod_loop category} - internal namespace for "special group of block modifier"{link: [perl 6 lookup tablet]Loops} that turn the "block"{link: block} into a loop - example : _*"loop"{link: loop}*, *"repeat"{link: repeat}*, *"for"{link: for}*_
* *statement_prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_prefix category} - internal namespace for block modifier - example : _*"do"{link: do}*_
* *Str* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Str type} - Perl string (finite sequence of Unicode characters)
* *Sub* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: sub type} - Perl subroutine object
* *"sub"{link: [Perl 6 Block tablet] sub}* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: sub} - defines a subroutine, a block callable by name
* *Submethod* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: submethod type} - Perl subroutine acting like a method
* *submethod* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: submethod} - defines methods, not inherited by subclasses
* _subroutine_ {section: subroutine} - block of code callable by name
* *subset* {section: subset} - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }
* *":subst"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: subst adverb} - parse as "substitution regex"{link: [Perl 6 Regex Tablet] Substitution}, *Q :subst /.../.../* is alias to *"s/.../.../"{link: s op}*
* *"subst"{link: [Perl 6 Regex Tablet] Substitution}* _(string method)_ {section: subst} - method alias to {{ s/.../.../, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/; }}
* *substr* _(string method)_ {section: substr} - the scalar substring function like in Perl 5
* *succ* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: succ} - returns the successor of $x (only parameter), alias to *++* operator (see *"pred"{link: pred}*)
* *supersede* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: supersede} - replaces definitions of an existing name, e.g. methods and attributes of a *"class"{link: class}* or *"grammar"{link: grammar}*, see also: *"augment"{link: augment}*

^^ "T"{link: Index} {section: T}

* *:t* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: t filetest} - filehandle is opened to a tty (terminal)
* *\T* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital T} - anything but a tab
* *\t* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash t} - tab, not visible character
* *"take"{link: [Perl 6 Block Tablet ]gather and take}* {section: take} - can add several item to the list of return values of a *"gather"{link: gather}* block
* *tan* _"(numeric op)"{link: [perl 6 Operator Tablet] numeric context}_ {section: tan} - tangent, trigonometric function, takes angle in radian; see also *"to-radians"{link: to-radians}*, *"cos"{link: cos}*, *"sin"{link: sin}*
* *temp* {section: temp} - defines variables as temporary, synonym for the Perl 5 _local_
* *term* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: term category} - namespace of terms, used to redifine them or make a new with a macro
* <n> *:th* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: th modifier} - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd)
* *tighter* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: tighter} - specifies the "precedence of an operator"{link: [perl 6 lookup tablet] table of precedence} higher than an existing operator
* *":to"{link: [Perl 6 basics tablet]Heredocs}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: to adverb} - defines end marker for the following heredoc, *:to* is short for *":heredoc"{link: heredoc adverb}*
* *to-radians* {section: to-radians} - convert from $base (second parameter) to radians, opposite of *"from-radians"{link: from-radians}*
* *token* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: token} - *"regex"{link: regex}* method without backtracking, alias to _*"regex"{link: regex}* *":ratchet"{link: ratchet modifier}*_ , part of a *"grammar"{link: grammar}* , see also *"rule"{link: rule}*
* _topicalizer_ {section: topicalizer} - every keyword that sets the *"$_"{link: context var}* variable, eg given, for
* *touch* (filehandle method) {section: touch} - update timestamps on a file (like the Unix command)
* *"tr///"{link: [Perl 6 Regex Tablet] Transliteration}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: tr op} - transliteration (as in Perl 5), translating some character in a string into others, alias to *Q :trans /.../.../*
* _trait_ {section: trait} - additional property of a variable, defined at compile time, see *"but"{link: but}*, what other languages call _trait_ Perl calls "role"{link: role}
* *trait_auxiliary* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: trait_auxiliary category} -
* *trait_verb* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: trait_verb category} - example : *"of"{link: of}*
* *":trans"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: trans adverb} - evals the quoted as "transliteration"{link: [Perl 6 Regex Tablet] Transliteration} aka tr /.../.../ aka .trans("..." => {{"..."}})
* *"trans"{link: [Perl 6 Regex Tablet] Transliteration}* _(string method)_ {section: trans} - method name for *"tr/.../.../"{link: tr op}* operator, $str.trans( %mapping ) equals {{$str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;}}
* *{{$~Trans}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: trans var} - current "grammar"{link: grammar} of the transliteration language (used by *trans()* aka *"tr/.../.../"{link: tr op}*)
* *triangle* _(list method)_ {section: triangle} - alias to *"[\ ]"{link: square bracket slash metaop}* "metaoperator"{link: [perl_6_lookup_tablet] metaoperators} - example: {{ [\+] @a = @a.triangle(&[+]) }}
* *True* {section: True} - boolean value aka Bool::True, 1 in numeric context
* *truncate* _(num op)_ {section: truncate} - closest integer to $f (only parameter) whose absolute value is not greater than the absolute value of $f
* *trusts* {section: trusts} - allows a class the acess to otherwised sealed namespaces
* *twigil* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: twigil category} - internal namespace for "twigils"{link: [Perl 6 Variable Tablet] Twigils}, used to redifine them or define your own with a macro
* _"twigil"{link: [perl 6 lookup tablet] Twigils}_ {section: twigil} - second(ary) _"sigil"{link: sigil}_ indicating a special property of a variable
* *type_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: type_declarator category} - - example: *"subset"{link: subset}*
* *{{$*TZ}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: tz global var} - local time zone

^^ "U"{link: Index} {section: U}

* *:u* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: u filetest} - report if file has setuid bit set
* *\U[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital U} - everything within the brackets is uppercase
* *uc* {section: uc} - make all string chars uppercase
* *ucfirst* {section: ucfirst} - make first char of a string uppercase
* *{{$*UID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: uid global var} - real user ID of the running process (*"$*PID"{link: pid global var}*) owner (user), was @< and $UID in Perl 5
* *UNDO* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: UNDO} - marks a special block, executed at every unsuccessful block exit, part of *"LEAVE"{link: LEAVE phaser}* queue
* *uniq* _(list method)_ {section: uniq} - only unique elements of a list
* *"unless"{link: [Perl 6 Block tablet] unless}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: unless} - flow control modifier, opposite of if, runs block if expression is false
* *"until"{link: [Perl 6 Block tablet] until}* _"(block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: until} - opposite of while, runs block repeatedly is long as expression is false
* *unwrap* {section: unwrap} - remove an enclosing subroutine (see *"wrap"{link: wrap }*)
* *<upper>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: upper subrule} - a single uppercase character
* *"uri"{link: [Perl 6 IO Tablet] }* {section: uri} - returns IO::Streamable descendant for accessing content of that URI (only pramameter typed *"Str"{link: str type}*)
* *{{$?USAGE}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: usage compiler var} - default usage message generated at compile time
* *"use"{link: [Perl 6 Subroutine tablet] }* {section: use} - load a module, check Perl version, import definitions (see *"need"{link: need}* and *"import"{link: import}*)

^^ "V"{link: Index} {section: V}

* *\V* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital V} - anything but vertical whitespace
* *\v* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash v} - vertical whitespace (LF + CR + FF + Line Tab + Next Line + Line Separator + Paragraph Separator), see also *"\s"{link: backslash s}* (whitespace)
* *value* _"(pair method)"{link: [Perl 6 Variable Tablet] Pair}_ {section: value} - gets value (second) value of a pair (opposite of *"key"{link: key}*) - example: (key => 'value').value; # returns 'value'
* *values* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: array values} - returns an array of values like the var itself in "list context"{link: list context} does
* *values* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: values} {section: values hash} - returns an array of just the values - example: _(1 => 2, 3 => 4).values; # returns (2,4)_
* *{{$*VM}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: vm global var} - running virtual machine, might want to use _$VM.name_, see also: *"$*DISTRO"{link: distro global var}* and *"$*KERNEL"{link: kernel global var}*
* *{{$?VM}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: vm compiler var} - virtual machine the program is compiled for, see also: *"$?DISTRO"{link: distro compiler var}* and *"$?KERNEL"{link: kernel compiler var}*

^^ "W"{link: Index} {section: W}

* *:W* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital w filetest} - check if file is writeable by real uid/gid
* *:w* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: w filetest} - check if file is writeable by effective uid/gid
* *":w"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: w adverb} - split quoted string on words (on whitespaces), no quote protection, short form of *":words"{link: words adverb}*, used in *"qw/.../"{link: qw op}*
* *\W* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital W} - anything but a word character
* *\w* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash w} - word character (Unicode alphanumeric plus "_")
* *|w* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: pipe w} - word boundary, zero width space between two *\w*, alias to *"<wb>"{link: wb subrule}*, see also: *"|c"{link: pipe c}* and *"|g"{link: pipe g}*
* *"wait"{link: [Perl 6 IO Tablet] Processes}* {section: wait} - waits for a child process to terminate and returns the child status object, process ID in numeric context
* *want* {section: want} {section: want} - produces a signature object that provides information about the context from which the current routine was called
* *"warn"{link: [Perl 6 IO tablet] warn}* {section: warn} - makes output via standart error output ($ERR - usually the command line), similar to *"note"{link: note}*, but works more like *"print"{link: print}*, without appending *"\n"{link: backslash n}*
* *<wb>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: wb subrule} - zero-width word boundary between an *"\w"{link: backslash w}* and a *"\W"{link: backslash capital w}* character aka *"\b"{link: backslash b}*, alias to *|w*, see also *"<ww>"{link: ww subrule}*
* *WHAT* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHAT introspection} - short name of the class that an object belongs to
* *Whatever* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Whatever} - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch), alias to *"*"{link: asterisk}*
* *WHEN* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHEN introspection} - (reserved for events?)
* *"when"{link: [Perl 6 Block tablet] when}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: when} - executes its following code block, when parameter matches against *"$_"{link: context var}* (set by *"given"{link: given}* or *"for"{link: for}*); (see also *"default"{link: default}*)
* *WHENCE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHENCE introspection} - autovivification of closures
* *WHERE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHERE introspection} - memory address of the object
* *where* {section: where} - defines subtypes of data - example: _{{subset Month of Int where { 1 <= $^a <= 12 } }}_
* *WHICH* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHICH} - object ID (type)
* *"while"{link: [Perl 6 Block tablet] while}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: while} - flow control modifier runs block repeatedly as long as en expression is *"True"{link: true}*
* *WHO* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHO introspection} - package, that support that object, long name in string context
* *WHY* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHY introspection} - reserved for documentation, see also *"#="{link}*
* *will do* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: will do} - block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition
* *words* _(string method)_ {section: words} - splits a sting into a list of words - example: _{{ $input.words($limit) equals $input.comb( / \S+ /, $limit ) }}_
* *":words"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: words adverb} - split quoted string on words (on whitespaces), no quote protection, long form of *":w"{link: w adverb}*, used in *"qw/.../"{link: qw op}*
* *wrap* {section: wrap} - creates enveloping subroutine (see also *"unwrap"{link: unwrap}*)
* *"write"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: write} - writes content of all parameter into that buffer
* *<ws>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: ws subrule} - whitespace between words aka *"\s*"{link: backslash s}*
* *":ww"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: ww adverb} - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and *""...""{link: double quotation marks}* sourrounded strings are taken as single words), short form of *":quotewords"{link: quotewords adverb}*, used in *"<<...>>"{link: double angle brackets}*
* *{{<ww>}}* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: ww subrule} - zero-width space inside of a word between two *"\w"{link: backslash w}* character, see also *"<wb>"{link: wb subrule}*

^^ "X"{link: Index} {section: X}

* *X* _(list op)_ {section: capital X} - Cross product of two arrays, alias of *"cross"{link: cross}* method - example: _1,2 X 3,4 == 1,3,1,4,2,3,2,4;_
* *x* _"(string op)"{link: [perl 6 Operator tablet] String Context}_ {section: x} - string replicate operator to single string - example: _'ab' x 3 == 'ababab';_
* *X*<op> _"(meta op)"{link: [Perl 6 lookup tablet] Metaoperators}_ {section: capital x metaop} - Cross product with hyper operator, alias of *"crosswith"{link: crosswith}* method - example: _<a b> X~ <y z> == <ay az by bz>;_
* *:X* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: capital x filetest} - check if file is executable by real uid/gid
* *:x* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: x filetest} - check if file is executable by effective uid/gid
* *:x* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: x adverb} - quoted string will be evaluated as Perl code (like *"eval"{link: eval}*) and replaced with its result, alias to *"Q"{link: capital q op}* *":exec"{link: exec adverb}* */.../* and *"qx/.../"{link: qx op}*
* *:x*(<n>) _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: x modifier} - searching n times (n is an int) with this pattern
* *\X[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital X} - anything but the character given in hexadecimal (brackets optional)
* *\x[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash x} - character given in hexadecimal (brackets optional)
* *<xdigit>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: xdigit subrule} - single hexadecimal digit char
* *xor* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: xor} - "infix"{link: infix category} logical _eXclusive OR_ operator (_XOR_), *"True"{link: true}* if only one side has positive value, returns otherwise left value, low precedence version of *"^^"{link: double caret op}*
* *xx* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ {section: xx} - replicate a list _$n_ (second operand) times - example: `{{ 'ab' xx 3 = <ab ab ab> }}`

^^ "Y"{link: Index} {section: Y}

* _"yadda operator"{link: [perl 6 Operator tablet] yadda}_ {section: yadda operator} - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: *"..."{link: triple dot yadda op}*, *"???"{link: triple question mark}* and *"!!!"{link: triple exclamation mark}*

^^ "Z"{link: Index} {section: Z}

* *Z* _(list op)_ {section: capital Z} - alias to zip _(list op)_ , joines 2 lists - example: _1,2,3,4 Z 8,9 == 1,8,2,9_
* *Z*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: capital Z metaop} - joines the values from same position of 2 lists with following operator and produces in that manner a new list
* *zip* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: zip} - zip operator, joines 2 lists, alias to *Z* operator - example: _{{ @a Z @b = (@a; @b).zip }}_
* *zipwith* _(list method)_ {section: zipwith} - alias to *"Z metaoperator"{link: capital z metaop}* - example: _{{ @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) } }}_

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

----

"Overview"[Perl 6 Tablets] - _Chapter:_ "0:History"[Perl 6 History Tablet], "1:Design"[Perl 6 Language Design Tablet], "2:Basics"[Perl 6 Basics Tablet], "3:Var"[Perl 6 Variable Tablet], "4:Op"[Perl 6 Operator Tablet], "5:IO"[Perl 6 IO Tablet], "6:{}"[Perl 6 Block Tablet], "7:Sub"[Perl 6 Subroutine Tablet], "8:OOP"[Perl 6 OOP Tablet], "9:Rx"[Perl 6 Regex Tablet], "10:Meta"[Perl 6 Meta Tablet]
"Intro"[Perl 6 Intro Tablet] - _Appendices:_ *"A:Index"[Perl 6 Index Tablet]*, "B:Tables"[Perl 6 Lookup Tablet], "C:Cook"[Perl 6 Cookbook Tablet], "D:Delta"[Perl 6 Delta Tablet], "E:Best of"[Best Of Perl 6 Tablet], "F:Links"[Perl 6 Links Tablet]

----


Upload Files

Click "Browse" to find the file you want to upload. When you click "Upload file" your file will be uploaded and added to the list of attachments for this page.

Maximum file size: 50MB

 
 
 
File Name Author Date Uploaded Size

Save Page As

Enter a meaningful and distinctive title for your page.

Page Title:

Tip: You'll be able to find this page later by using the title you choose.

Page Already Exists

There is already a page named XXX. Would you like to:

Save with a different name:

Save the page with the name "XXX"

Append your text to the bottom of the existing page named: "XXX"

Upload Files

Click "Browse" to find the file you want to upload. When you click "Add file" this file will be added to the list of attachments for this page, and uploaded when you save the page.

 
 
 
Add Tags

Enter a tag and click "Add tag". The tag will be saved when you save the page.

Tag: 

Suggestions: