Perl 6

Perl 6 Index Tablet: Revision 487

{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}*

* *!* _"(context op)"{link: [Perl 6 lookup tablet] Contextualizers}_ {section: exclamation mark} {section: exclamation mark op} {section: exclamation mark context op} - logical negation (_NOT_), forces _"boolean context"{link: [perl 6 Operator tablet] bool context}_, 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"{link: why introspection}_ 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: ampersand sigil} - _"sigil"{link: sigil}_ of "callables "{link: [perl 6 Variable Tablet] Callable} like "subs"{link: sub}, "methods"{link: method} and other "blocks"{link: block}
* *&*() _"(context op)"{link: [Perl 6 lookup tablet] Contextualizers}_ {section: ampersand context op} - forces "callable"{link: [perl 6 Variable Tablet] Callable} context, alias to *"code"{link: code context op}*
* *&* _"(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 Operator tablet] 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} {section: angle brackets var} - "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
* *=* _"(twigil)"{link: [Perl 6 lookup tablet] Twigils}_ {section: equal sign twigil} - "pod"{link: pod} variable, mapped content from pod sections of this file - examples: *"$=pod"{link: pod pod var}* and *"$=data"{link: data pod var}*
* {{<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"{link: [perl 6 Operator tablet] 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 _"boolean context"{link: [perl 6 Operator tablet] bool 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} - autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables
* *^* _"(signature symbol)"{link: [Perl 6 lookup tablet] Signature Symbols}_ - prefix of metaclass methods, _$obj.^methods();_ is shortcut for _"$obj.HOW.methods($obj);"{link: HOW introspection}_
* *^* _"(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: underscore var} {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} {section: tilde context op} - forces _"string context"{link: [perl 6 Operator tablet] String context}_ (stringify) and/or concatenate strings, alias for *"cat"{link: cat}*
* *~* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: tilde twigil} - _"twigil"{link: twigil}_ for a "grammar"{link: grammar} of a sublanguage like *"$~MAIN"{link: main lang var}*
* *~&* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde ampersand op} - characterwise _AND_, forces _"string context"{link: [perl 6 Operator tablet] String context}_
* *~<* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde lower op} - characterwise left shift, forces _"string context"{link: [perl 6 Operator tablet] String context}_
* *~>* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde greater op} - characterwise right shift, forces _"string context"{link: [perl 6 Operator tablet] String context}_
* *~^* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde caret op} - characterwise _XOR_, forces _"string context"{link: [perl 6 Operator tablet] 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] 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* {section: 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"{link: when}* block now, see also: *"last"{link: last}* and *"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"{link: [perl 6 lookup tablet] Callframe Methods} the callable (routine) from which as routine was invoked
* *callframe* {section: callframe} - returns an object that describes a particular callframe as described by a "list of matchers"{link: [perl 6 lookup tablet] Callframe Methods}
* *callwith* {section: callwith} - callable-method 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"{link: [perl 6 Operator tablet] String context}_ and joines them like with *"~"{link: tilde op}*, alias to _".join('')"{link: 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"{link: bytes modifier}*, *"codes"{link: codes modifier}*, *"graphs"{link: graphs modifier}*
* *"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* _"(context op)"{link: [Perl 6 lookup tablet] Contextualizers}_ {section: code context op} - forces "callable"{link: [perl 6 Variable Tablet] Callable} context, alias to *"&()"{link: ampersand context op}*
* *: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
* _compilation_ - reading the human written source code and make it an executable (piece of) program
* _compile time_ {section: compile time} - time when Perl converts source code to executable form (bytecode), before _"runtime"{link: runtime}_
* *Complex* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: complex type} - Perl object type to hold a complex number
* *"conjugate"{link: [perl 6 Operator tablet]}* {section: conjugate} - convert "complex number"{link: complex type} into real (*"Num"{link: num 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 operator"{link: capital X}* - example: {{ @a X @b = (@a; @b).cross }}
* *crosswith* _(list method)_ {section: crosswith} - alias to *"X metaoperator"{link: capital X metaop}*: {{ @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 pod var} - handle for the data block (=begin data ... =end data), use _$=data.lines_ for iterations over the lines of it
* *"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 run if no *"when"{link: 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), see also: *"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"{link: False}*, see also *"default"{link: default}*
* *"elsif"{link: [Perl 6 Block tablet] elsif}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: elsif} - alternative *"if"{link: 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"{link: [perl 6 Operator tablet] 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 _"compiles"{link: compilation}_ a "string"{link: str type} and runs it, returns a 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} - executing a piece of program, before that all variables will be replaced with their content
* *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"{link: [perl 6 Operator tablet] 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 lang 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} - get an instance the objects metaclass, its "Higher Order Workings"
* *hyper* {section: hyper} - forces none-lazy list context, that ignores the order of results (allows 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} - if the following expression _"evals"{link: evaluation}_ to *"True"{link: True}*, the block after that will be run, opposite of *"unless"{link: unless}*, can also be written at the end of an expression
* *: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 5s $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: [perl 6 Operator tablet] 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 _"$str.comb( / ^^ \N* /, $limit )"{link: comb}_, 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"{link: compile time}_
* *{{$~MAIN}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: main lang 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} - an unicode newline character, its {{\u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A}}
* <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* _"(context op)"{link: [Perl 6 lookup tablet] Contextualizers}_ {section: not} - logical _NOT_ operator, converts to _"boolean context"{link: [perl 6 Operator tablet] bool context}_ which means it returns *"False"{link: false}* if value is positive or otherwise, low precedence version of *"!()"{link: exclamation mark op}*
* *"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 lang 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} {section: pair} - object to hold a single key-to-value association
* *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}* (sequence) 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"{link: complex type} (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 <n>th 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 a line from *"$*IN"{link: in global var}*
* _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 lang 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 lang 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 - example: _4 R- 3 # result is -1 = 3- 4_
* *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 lang 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} - can be put before a _"block"{link: block}_ so that *"while"{link: while}* or *"until"{link: until}* can be written after the closing bracket, these loops will always run at least one time because the condition will be checked after each run
* *"rename"{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} - block of code callable by name, can have a _"signature"{link: signature}_ and a return type
* *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 execution hits a certain part of the program, after _"compile time"{link: compile time}_
* *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"{link: subst adverb} /.../.../* 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 lang var}* or *"$~MAIN"{link: main lang 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* _"(context op)"{link: [Perl 6 lookup tablet] Contextualizers}_ {section: so op} - converts value into the _"boolean context"{link: [perl 6 Operator tablet] bool 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 - example: _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
* *subset* {section: subset} - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }
* *"subst"{link: [Perl 6 Regex Tablet] Substitution}* _(string method)_ {section: subst} - method alias to _"s/.../.../"{link: s op}, $str.subst( /pattern/, "replacement" )_, equals $str ~~ s/pattern/replacement/;
* *":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"{link: subst adverb} /.../.../* is alias to *"s/.../.../"{link: s op}*
* *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"{link: trans adverb} /.../.../*
* _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 lang var} - current "grammar"{link: grammar} of the transliteration language (used by *"trans()"{link: 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} - if the following expression _"evals"{link: evaluation}_ to *"False"{link: False}*, the block after that will be run, can also be written at the end of an expression, opposite of *"if"{link: if}*
* *"until"{link: [Perl 6 Block tablet] until}* _"(block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: until} - runs block repeatedly as long as the following expression _"evals"{link: evaluation}_ to *"False"{link: False}*, can be combined with *"repeat"{link: repeat}*, can also be written at the end of an expression, opposite of *"while"{link: while}*
* *unwrap* {section: unwrap} - remove an enclosing subroutine, see also: *"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 introspection} - object ID (type)
* *"while"{link: [Perl 6 Block tablet] while}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: while} - runs block repeatedly as long as the following expression _"evals"{link: evaluation}_ to *"True"{link: True}*, can be combined with *"repeat"{link: repeat}*, can also be written at the end of an expression, opposite of *"until"{link: until}*
* *WHO* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHO introspection} - package, that support that object, long name in _"string context"{link: [perl 6 Operator tablet] String context}_
* *WHY* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHY introspection} - reserved for documentation, see also *"#="{link: pound equal}*
* *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 )"{link: comb}_
* *":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]

----