Perl 6
Perl 6 Index Tablet: Revision 246
{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 of all operators, methods, builtins, options *(bold)* and some technical terms _(italic)_ with short explanations. Each bold term is followed by a link to a condensed summary of its category in appendix B.

* *!* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ - logical negation, forces boolean context, high precedence version of *"not"{link: not}*
* *!* _"(twigil)"{link: [Perl 6 lookup tablet] Twigils}_ - _twigil_ of private class and object variables
* *!* - suffix for a required parameter in signatures
* *!*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - negates (mostly comparison operators)
* *!!* - second part of the ternary (conditional) operator after *"??"{link: ??}*
* *!!!* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ - yadda operator that calls *"die"{link: die}*
* *"" ""{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - double quoting, interpolates with :s, :a, :h, :f, :c, :b (all vars, functions, blocks, control chars), alias to *qq/.../* or *Q :qq/.../*
* *"#"{link: [Perl 6 Basics Tablet]Single Line}* - 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] Multi Line}* - 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}_ - prefix of "scalar variables"{link: [perl 6 Variable Tablet] Scalar}
* *$()* _"(context op)"{link: [perl 6 lookup tablet]Contextualizers}_ - forces scalar context, alias to the *"item()"{link: item}* function
* *$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - end of the string
* *$$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - end of a line
* *%* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - prefix of "hash variables"{link: [perl 6 Variable Tablet] Hash}
* *%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - gives remainder of a modulo division, forces numeric context
* *%()* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces hash context, alias to the *"hash()"{link: hash}* function
* *%* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - repeat char or group as long as separated by right expression; for example, `\d % ','` matches `1,2,3,4,5`
* *%%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - `Bool::True` if the left value is evenly divisible by the right value
* *%%* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - repeat char or group as long as separated by right expression like %. but allows trailing separator; for example, `\d %% ','` matches `1,2,3,4,5,`
* *"&"{link: [perl 6 Variable Tablet] Callable}* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - prefix of "callable variables"{link: [perl 6 Variable Tablet] Callable}
* *&* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ - junctive _AND_, requires that all conditions are met
* *&* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - match multiple patterns (_AND_-connection of patterns)
* *&&* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ - short circuit _AND_, evals right side if left side returns true, high precedence version of *and*
* *"' '"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - simple quoting, just / and ' must be escaped, alias to *q/.../* or *Q :q/.../*
* *()* - grouping of values (parameters)
* *()* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - encompass a _subregex_ / _submatch_
* *{{*}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - multiplies numbers, forces numeric context
* *{{*}}* _(term)_ - synonym for *"Whatever"{link: Whatever}*, for example, means `Inf` in a range operator (*..*); means the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element
* *{{*}}* - prefix which indicates _slurpy_ arrays in signatures
* *{{*}}* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ - _twigil_ of global variables
* *{{**}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - raises a number to a power, forces numeric context
* *{{**}}* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - 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}_ - adds numbers, forces numeric context
* *+&* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - bitwise and, forces numeric context
* *++* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to *"succ"{link: succ}*
* *+<* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - shift left in numeric context
* *+>* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - shift right in numeric context
* *+^* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - bitwise xor in numeric context
* *+|* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - bitwise or in numeric context
* *","{link: [perl 6 Variable Tablet] Array}* - "list"{link: [perl 6 Variable Tablet] Array}-generating operator
* *{{-}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - subtracts numbers, forces numeric context
* *--* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to *pred*
* *-->* - declares the type of the return value of a routine, type name is placed after this arrow at the end of a signature
* *{{->}}* - declares named parameters for a block (pointy block)
* *.* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ - _twigil_ of public accessors (getter/setter)
* *.* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - matches any character (including a newline, unlike in Perl 5)
* *..* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_, _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ - range generating operator, produces a `Range` object in "item context"{link: [perl 6 lookup tablet]Contextualizers}
* *"..."{link: [perl 6 Operator tablet] Sequence Operator}* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ - sequence generating operator, infix operator for list generation
* *...* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ - term that calls *fail* (exception), marks unimplemented empty routine bodies
* */* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - divides numbers, forces numeric context
* */* _"(rat composer)"{link: [Perl 6 Basics Tablet] Rational Number}_ - inside round braces (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
* *//* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ - short circuit _defined or_, returns the first defined value (from left to right), similar to *orelse*, high precedence version of *err*
* *{{\0}}*_B_*{{[<n>]}}* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - character given in octal, decimal or hex (when _B_ is 'o', 'd' or 'x'); brackets optional
* *:* - _"pair"{link: [perl 6 variable tablet] pair}_ generation operator, also known as _adverbial_ syntax
* *:* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - 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}_ - _twigil_ of autogenerated named parameters of a block
* *:*_B_*<N>* - "general radix form"{link: [Perl 6 Basics Tablet]General Radix Form} for literals, makes a number N in base B (up to 36), for example `:2<1000001>` is decimal 65
* *:* - (flow control) - suffix of all labels "you can jump to"{link: [Perl 6 Block Tablet] goto}
* *:* - prefix of a _named parameter_ in a signature
* *::* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - abstraction sigil, introducing a type variable in a signature
* *::* - "namespace"{link: [perl 6 module tablet] Modules} separator (like in Perl 5)
* *"::="{link: [Perl 6 Variable Tablet] Binding}* - "binds"{link: [Perl 6 Variable Tablet] Binding} a value or variable to a variable at compile time
* *":="{link: [Perl 6 Variable Tablet] Binding}* - creates an alias to a variable at runtime (_"binding"{link: [Perl 6 Variable Tablet] Binding}_)
* *";"{link: [Perl 6 Basics Tablet] Statements}* - 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 Comparsion}_ - infix op, lesser than, Bool::True if numerically ordered the left comes before the right operand
* *<->* double pointy syntax to assign a rw parameter to a block
* *<<* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - applies the operator on the left as hyper operator to the array on the right
* *<<==* - 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}_ - circumfix quoting operator for grouping with autoquoting and evaluation (alias to Q :qq :ww /.../)
* *<=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparsion}_ - less than or equal, numeric comparison operator
* *<==* - leftward pointing feed operator
* *<=>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparsion}_ - numeric less-equal-greater comparison for sortable classes, does *cmp* in numeric context as leg does in string context
* *"< >"{link: [Perl 6 Basics Tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../ or qw/.../)
* *< >* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - embraces an subrule (assertion)
* *"="{link: [Perl 6 Variable Tablet] Assignment}* _(Op)_ - "assignment"{link: [Perl 6 Variable Tablet] Assignment}, right side is evaluated and assigned to the left
* *{{<op>=}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - self assignment, left side is one oper and the result is assigned to ($a += 3; equals $a = $a + 3)
* *=:=* _(comparison 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 Comparsion}_ - equality of value, does a cmp in numerical context as _leg_ does in string context
* *===* _(comparison op)_ - identity, equality of value and type
* *==>* _(op)_ - rightward pointing feed operator
* *==>>* _(op)_ - rightward pointing feed operator that adds values to an existing list (append-mode)
* *=>* _(op)_ - pair (and hash) constructor, _fatarrow_
* *>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparsion}_- infix op, greater than
* *>=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparsion}_ - infix op, greater than or equal
* *>>* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - binds operator (right) as hyper operator to an array (left)
* *"?"{link: [perl 6 Operator tablet] logical selection}* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces binary context in an expression, returns _Bool::False_ when value is 0 or empty, otherwise _Bool::True_
* *?* - suffix for optional named parameters in signatures
* *?* - quantifier for 0 or 1 occurrence in Regexes
* *?* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ - secondary sigil for constant compiler hint variables
* *?&* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ - logical AND op, and combinator, forces binary context
* *?? !!* (logical op) {section: ??} - ternary or conditional operator; shortcut for *"if"{link: if}* and *"else"{link: else}*
* *???* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ - yadda operator that calles *"warn"{link: warn}*
* *?^* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ - logical XOR, forces operands into boolean context
* *?|* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ - logical OR, forces operands into boolean context
* *@* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - sigil of an "array"{link: [perl 6 Variable Tablet] Array}
* *@()* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces (flattened) array context, alias to *list()* function
* *<var>[ ]* - postcircumfix operator, appended on an array var, returns an array slice with values which indexes was inside the brackets
* *[ ]* - circumfix operator that creates a reference to an array that holds all values that encompas these brackets
* *{{[<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - circumfix reduction metaop, close to functional "reduce", applies the operator between all elements of an array
* *{{[\<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - circumfix reduction metaop, applies above reduction to a series of lists made of array slices ranging in length from 1 to the complete length of the original list
* *\* - "capture generator"{link: [perl 6 variable tablet] Capture}, creates a reference to the following structure
* *\* - 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}_ - junctive xor, requires that one value in a list is true
* *^* - upto operator, ^$limit expands to 0 ..^ +$limit range
* *^* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_ - in range definitions, it excludes a limit value, in scalar context see smartmatch
* *^* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ - for autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables
* *^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - start of the string
* *^^* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: ^^} - logical xor, combines expressions, returns true when only one expression is true, otherwise false, high precedence version of *xor*
* *^^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - start of a line
* *{}* - circumfix operator: encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a '=>'
* *|* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ - junctive OR, requires that a condition is fulfilled
* *|* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - match alternate patterns (OR - connection of patterns)
* *|*() _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - flatten "capture"{link: [perl 6 variable tablet] Capture} object into arglist, (named parameter)
* *||* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ - short circuit OR, evaluates sequentially, ends evaluation at the first expression that returns true, high precedence version of *or*
* *||*() _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - flatten "capture"{link: [perl 6 variable tablet] Capture} object into semicolon list, (positional parameter)
* *"~"{link: [perl 6 Operator tablet] String Context}* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(string op)"{link: [perl 6 Operator tablet] string context}_ - forces string context (stringify) and/or concatenate strings, synonym for cat
* *~&* _"(string op)"{link: [perl 6 Operator tablet] string context}_ - characterwise and, forces string context
* *~<* _"(string op)"{link: [perl 6 Operator tablet] string context}_ - characterwise left shift, forces string context
* *~>* _"(string op)"{link: [perl 6 Operator tablet] string context}_ - characterwise right shift, forces string context
* *~^* _"(string op)"{link: [perl 6 Operator tablet] string context}_ - characterwise xor, forces string context
* *~|* _"(string op)"{link: [perl 6 Operator tablet] string context}_ - characterwise or, forces string context
* *"~~"{link: [perl 6 Operator tablet] smartmatch}* - smartmatch operator, compares (almost) all variable and data types

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

* *:a* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - demands evaluation of array variables, short form of ":array", included in "", qq and {{<<>>}}
* *:a* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - no distinction between same chars with or without accent (funny symbols above), short for ":ignoreaccent"
* *:aa* _"(regex modifier)"{link: [Perl 6 lookup Tablet]Regex Modifier}_ - only for substitutions, replacing with chars that have the same accent pattern as the replaced, short for ":sameaccent"
* *abs* _(numeric op)_ {section: abs} - returns numeric absolute value
* *after* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparsion}_ - generic comparison operator used by the Order class, true if left should follow right
* *all* - junctive AND operator
* *and* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ - short circuit AND, returns the last defined value (from left to right), similar to *"andthen"{link: andthen}*, low precedence version of *&&*
* *andthen* - logical AND short circuit operator, transferring $_ from first to second block/command, if first do succeed
* *anon* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ - introduces names that aren't to be stored anywhere (anonymous)
* *Any* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ - Perl 6 object (default routine parameter type, excludes junction)
* *any* {section: any} - junctive OR operator
* *arity* _(routine method)_ - returns how many parameters this routine requires, take *".count"{link: count}* if you want have the optional included
* *Array* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl Array, a series of *Scalar* value container, or a variable that stores such a list
* *array()* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces array context, alias to *@()*
* *":array"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - demands evaluation of array variables, long form of ":a", included in "", qq and {{<<>>}}
* *as* _"(parameter trait)"{link: [Perl 6 lookup tablet]parameter Traits}_ - data coming through that parameter will be coerced to the type following *"as"{link: as}*
* *as* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ - inner type constraint that a routine imposes on its return value
* *assoc* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ - specifies the "associativity of an operator"{link: [Perl 6 Lookup tablet]operator associativity} explicitly
* *assuming* - method of all subroutine reference objects that enables Currying
* _AST_ - (abstract syntax tree), tree like data structure, in which source code is transformed, before running the programm
* *async* _(block modifier)_ - allows the interpreter to parallelize the following
* *augment* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ - adds definitions to an existing name, inserts new methods and attributes into a class/grammar or replaces them

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

* *:b* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)
* *:b* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, short form of *:backslash*, included in "", qq and {{<<>>}}
* *\B* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - Match when not on a word boundary
* *\b* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - word boundary
* *":backslash"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ _ - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, long form of ":b", included in "", qq and {{<<>>}}
* _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}_ - unordered collection of values that allows duplicates
* *before* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparsion}_ - generic comparison operator used by the Order class, true when left should precede right
* *BEGIN* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: BEGIN} - marks a special block or statement, executed at compile time, ASAP, only ever runs once
* _"Binding"{link: [Perl 6 Variable Tablet] Binding}_ - making two variables share the same content by pointing to same memory location
* *Bit* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Perl single bit (allows traits, aliasing, undef, etc.)
* *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}_ - An undifferentiated mass of bits
* *Block* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Executable objects that have lexical scopes (enclosed by curly braces)
* *Bool* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Perl boolean
* *break* _"(flow control)"{link: [perl 6 lookup tablet] Jump Commands}_ {section: break} - leave this when clause block now (see also *"leave"{link: leave}*)
* *Buf* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl buffer (a stringish array of memory locations), type for raw binary data
* *but* {section: but} - adds a role to a class
* *bytes* _(string method)_ - returns number of bytes used (a sort of length)
* *:bytes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex 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}_ - file is a character special file (e.g. terminals modems)
* *:c* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - forces evaluation of closures (blocks aka {{{ ... }}}) inside quotes, long form of ":closure", included in "", qq and {{<<>>}}
* *:c*(<n>) _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"
* *\C[<n>]* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - any character except the bracketed named or control character
* *\c[<n>]* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - named character or control character
* *cached* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ - marks a subroutine as being memoized
* *call* - execute a subroutine
* *caller* {section: caller} - object describing the code from which as routine was invoked
* *callframe* - returns an object that describes a particular call frame as described by a list of matchers
* *callwith* - submethode by which one can call a sub with a different signature
* *capitalize* - alias to a wordwise ucirst(lc($_)), makes first char of every word upper case, rest lowercase
* *"Capture"{link: [perl 6 variable tablet] Capture}* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Function call arguments (right-hand side of a binding)
* *cat* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: cat} - converts values of a list into string context and joines them like with '~', alias to _.join('')_
* *CATCH* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - marks a special block to catch exceptions, before *"LEAVE"{link: LEAVE}*
* *categorize* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, unlike *classify* the return value of the mapper can be listref to put the value in several categories or *Nil* to reject the value for categorisation
* *category* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - namespace of grammatical categories, in case you want to create a new one with a macro
* *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, was length in Perl 5
* *:chars* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - searching on character level (default), (see also bytes, codes, graphs)
* *"chdir"{link: [Perl 6 IO tablet] dir}* - changes the current working directory ($*CWD)
* *CHECK* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - marks a special block or statement, executed at compile time, ALAP, only ever runs once
* *chmod* - changes access rights of files
* *chomp* _(string method)_ {section: chomp} - returns a string with the last newline (if there is one) removed
* *chop* _(string method)_ - returns a string with the last character removed
* *chown* - changes owner of files
* *"chroot"{link: [Perl 6 IO tablet] chroot}* - change root directory on POSIX systems
* *circumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])
* *class* _(block modifier)_ {section: class} - declares a collection of methods that define an object
* *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*)
* *"close"{link: [Perl 6 IO tablet] close}* _(filehandle method)_ - 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}_ - forces evaluation of closures (blocks aka {{{ ... }}}) inside quotes, long form of ":c", included in "", qq and {{<<>>}}
* _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 Comparsion}_ {section: cmp} - general comparator, result: -1(lower than), 0 (equal), 1 (greater than), using the _Order_ class (see also *"leg"{link: leg}* and *<=>*)
* *Code* {section: Code} - data typ for code references of any kind
* *:code* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi
* _Coderef_ - reference (pointer) to an executable block of code (routine)
* *:codes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex 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 aka m//; default pattern is rx/./
* _compile time_ - the process when Perl converts source code to executable form
* *Complex* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ - Perl complex number
* *constant* _(var trait)_ - makes so declared var (_is constant_) a real constant
* *contend* _(block modifier)_ - marks a block as atomic, concurrent proceses have to wait
* _Context_ - when executing a function or operator Perl considers the expression from which the call was to return a scalar or other kind of result
* _Context variable_ - $_ is used by built in Perl functions as an implicit parameter
* *"continue"{link: [Perl 6 Block tablet] continue}* _(flow control)_ - makes execution in a 'given' also try the following 'when' clauses
* *:continue*(<n>) - _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":c"
* *CONTROL* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - marks a special block to catch control exceptions (like next/last/return etc), before *"LEAVE"{link: LEAVE}*
* *Cool* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Cool} - 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
* *count* _(routine method)_ {section: count} - returns how many parameters this routine takes (including optional), *.arity* counts just the required
* *cross* _(list method)_ {section: cross} - alias to *"X"{link: X}* operator: {{ @a X @b = (@a; @b).cross }}
* *crosswith* _(list method)_ {section: crosswith} - alias to *"X"{link: X}* metaoperator: {{ @a X~ @b = (@a; @b).crosswith(&amp;[~]) = (@a; @b).cross.slice.map { .reduce(&amp;[~]) } }}
* _Currying_ - creating a subroutine as a derivate from another with certain parameter to be predefined

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

* *:d* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - check if file is a directory
* *\D* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - nondigit
* *\d* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - digit
* *decode{link: [Perl 6 IO tablet] read}* _(Buf method)_ - transforms raw binary UTF (Buf) into readable UTF Text (Str)
* *"default"{link: [Perl 6 Block tablet] default}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: default} - following block will be executed if no when clause in surrounding block matched
* _Declarative Programming_ - programming paradigm that expresses the logic of a computation without describing its control flow
* *defer* _(block modifier)_ {section: defer} -
* *defined* - scalar method tests whether a value has been assigned to a variable
* *delete* _(hash method)_ {section: delete} - removes a key and value from a hash
* *denominator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ - returns the denominator of a rational number (value type Rat and FatRat)
* _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 (STDERR)
* *"dir"{link: [Perl 6 IO tablet] dir}* {section: dir} - returns all files of a given directory, excluding . and .. by default
* *"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* - checks if an objekt inherits this role
* *":double"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, long for ":qq"
* *Duration* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - The difference between two Instants
* *dynamic* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ - 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}_ - tests if file exists
* *\E* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - anything but an escape character
* *\e* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - escape character
* *each* {section: each} - variant of all() that promises to do things in order, is Positional/Iterable
* *eager* {section: eager} - forces eager evaluation (now), default for scalars
* *elems* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: elems} - returns number of elements
* *"else"{link: [Perl 6 Block tablet] else}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: else} - introduces the alternative block after an *"if"{link: if}* or *"elsif"{link: elsif}*, that is executed, when conditions of all alternatives resulted in *false* (see also *default*)
* *"elsif"{link: [Perl 6 Block tablet] elsif}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: elsif} - alternative if clause
* *encode{link: [Perl 6 IO tablet] read}* _(Buf method)_ - transforms readable UTF Text (Str) into raw binary UTF (Buf)
* *END* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: END} - marks a special block, executed at run time, ALAP, only ever runs once
* *ENTER* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: ENTER} - 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} - An immutable Pair
* *enum* {section: enum} - creates a set
* *EnumMap* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - A mapping of Enums with no duplicate keys
* *eq* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ {section: eq} - infix operator, proves equality in forced string 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* {section: eqv} - infix operator, compares the dynamic state of objects and values, in contrast with static *===*
* *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 *//*
* *eval* {section: eval} - just evaluates a string as a program and returns result and maybe error message in @!, second optional parameter defines a parser grammar which should understand the string
* *evalfile* {section: evalfile} - behaves like, and replaces Perl 5 *do* EXPR (filename, first parameter), with optional second parameter, which is a grammar that can parse that file
* *:ex* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - searching at all positions as long as it findes something (with backtracking), short for ":exhaustive"
* *Exception* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ - 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}_ - quoted string will be evaluated as Perl code (like *"eval"{link: eval}*) replaced with its result, alias to Q :x and qx //
* *:exhaustive* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - searching at all positions as long as it findes something (with backtracking), long for ":ex"
* *exists* {section: exists} - checks for existence of a variable, array or hash member, scalar method
* *exit* {section: exit} - stops all program execution, and returns Int $status (first parameter) to the calling environment
* *exp* {section: exp} - alias method to $base (first parameter) *{{**}}* $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} - file is a plain file (no socket or dir, ...etc.)
* *:f* _"(quoting adverb)"{link: [Perl 6 Lookup Tablet]Quoting Adverbs}_ - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":function", included in "", qq and {{<<>>}}
* *\F* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - anything but form feed
* *\f* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - 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} - data type object for an error, thrown by an unhandled exception
* *false* {section: false} - boolean value aka Bool::False
* *FatRat* _"(immutable type)"{link: [Perl 6 lookup tablet] immutable types}_ - 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
* *FIRST* _"(closure trait)"{link: [Perl 6 lookup tablet]closure traits}_ - marks a special block or statement, executed at loop initialization time, before any *"ENTER"{link: ENTER}*
* *flat* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: flat} - forces flat list context, opposite of *lol()*; example: _{{([2,3],[4,5]).flat results in: [2..5]}}_
* *flip* _(string method)_ {section: flip} {section: flip} - reverses order of characters in strings
* *"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; 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 $_ 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}_ - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":f", included in "", qq and {{<<>>}}
* _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} - report if file has setgid bit set
* *:g* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - searching for any finding (not just the first), short for :global
* *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 Comparsion}_ {section: ge}- greater than on equal; see laso *"gt"{link: gt}* or *"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)_ - reads one character from a file via file handle
* *getlogin* - returns the username of the account running the program, maybe less secure as *"getpwuid"{link: getpwuid}*
* *gethost* - establish a connection to a net host and retrieve information
* *"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 for *"when"{link: when}* clauses
* *:global* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: global} - searching for any finding (not just the first), long for :g
* *"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:")
* *grammar* {section: grammar} - special kind of class to hold regex token and rule definitions
* *:graphs* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: graphs} - 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} - gives all values of an array that pass a filters condition
* *gt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ {section: gt} - infix operator, greater than or equal, Bool::True if alphabetically ordered the right comes before the left (see also *lt*, *leg* and *<*)

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

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

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

* *:i* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - uppercase and lowercase variants of a letter are taken as the same letter, short for ":ignorecase" (same as in Perl 5)
* *"if"{link: [Perl 6 Block tablet] if}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ {section: if} - flow control conditional statement or block modifier, executes following code block only when a condition expression evaluates to *"true"{link: true}* (see also *"elsif"{link: elsif}* and *"else"{link: else}*)
* *:ignoreaccent* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - no distinction between same chars with or without accent (funny symbols above), short for ":a"
* *:ignorecase* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - uppercase and lowercase variants of a letter are taken as the same letter, long for ":i" (same as in Perl 5)
* *:ignoremark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, long for ":m"
* *:ii* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - only for substitutions, replacing with chars that have the same case pattern as the replaced, short for ":samecase"
* *"import"{link: [Perl 6 Subroutine tablet] }* {section: import} - just import definitions from an already loaded module (see *"use"{link: use}* and *"need"{link: need}*)
* *index* _(string method)_ {section: index} - finds the first occurrence of a substring in a string and returns the numerical position, opposite or _rindex_
* *Inf* - infinity, to generate infinite lazy lists
* *infix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that are surrounded by whitespace (\w) between 2 vars or statements _($a + $b)_
* *INIT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: INIT} - marks a special block or statement, executed at run time, ASAP, only ever runs once
* *inline* _(sub trait)_ -
* *Instant* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - A point on the continuous atomic timeline
* *Int* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - 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)_ - inverts the key => value relation of a pair or a series of pairs (hash)
* *IO* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl filehandle
* *is* {section: is} - bind a traits to a variable
* *item()* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces scalar context, alias to *$()*
* _Iteration_ - flow control, repeatedly executing a block
* *Iterator* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl list

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

* *join* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: join} - concatenates list elements into a string, optionally inserting another string between the elements

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

* *:k* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ - report if file has sticky bit set
* *KEEP* _"(closure trait)"{link: [Perl 6 lookup tablet]Closure traits}_ {section: KEEP} - marks a special block, executed at every successful block exit, part of *"LEAVE"{link: LEAVE}* queue
* *:keepall* _"(regex modifier)"{link: [Perl 6 Lookup tablet]Regex Modifier}_ - forces subrules to memorize everything (even comments)
* *key* _"(pair method)"{link: [Perl 6 Variable Tablet]Pair}_ {section: key} - gives the key part of a pair
* *KeyBag* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ - KeyHash of UInt (does Bag in list/array context)
* *KeySet* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ - KeyHash of Bool (does Set in list/array context)
* *keys* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: keys} - returns list of hash keys or array indexes
* *"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)
* *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}_ - file is a symbolic link
* *\L[<n>]* _"escape sequence"{link: [Perl 6 lookup tablet]Escape Sequences}_ - everything within the brackets is lowercase
* *LAST* _"(closure trait)"{link: [Perl 6 lookup tablet] closure traits}_ {section: LAST} - marks a special block, executed at loop termination time, after any *"LEAVE"{link: LEAVE}*
* *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}_ - number of final element
* *lazy* - forces lazy evaluation (as late as possible)
* *lc* _(string op & method)_ {section: lc} - make string lowercase
* *lcfirst* _(string op & method)_ - 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 Comparsion}_ {section: le} - infix operator, lower than or equal, (see *"lt"{link: lt}*, *"gt"{link: gt}*, *"ge"{link: ge}*)
* *LEAVE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: LEAVE} - 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 Comparsion}_ {section: leg} - infix operator, lower/equal/greater comparator, does *"cmp"{link: cmp}* in string context as {{<=>}} does in 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
* *"lines"{link: [Perl 6 Basics tablet] }* _(string method)_ - returns a chomped list of lines (chunks of character separated by \n) containing a string, {{ $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit ) }}
* *"lines"{link: [Perl 6 IO tablet] lines}* _(path|file handle method)_ - reads a file and returns content as array of lines
* *lines* _(io op)_ - returns an lazy iterator over all chomped lines of that input stream
* *list* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ - almost a no-op, just makes sure that $item (first parameter) can be iterated
* *log* {section: log} - logarithm of $x (first parameter) to the $base (second optional parameter - default is e, also known as ln )
* *log10* - logarithm to the base of 10, also known as lg
* *lol* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of *flat()*
* *"loop"{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}_ - specifies the "precedence of an operator"{link: [perl 6 lookup tablet] table of precedence} lower than an existing operator
* *lt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ {section: lt} - infix operator, lower than, Bool::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}_ - perform a regex based search in place ( stands for _match_ ), similar to rx _(quote regex op)_
* *:m* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for ":ignoremark"
* *Macro* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl compile-time subroutine
* *macro* - define a routine to alter source code at compile time
* *map* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - take a list, perform a block on each member, return a list of the results Arraymethode
* *Match* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl match, usually produced by applying a pattern
* *match* _(string method)_ {section: match} - method alias to m//, $str.match( /pat/ ) equals $str ~~ s/pat/;, returns a match object
* _match object_ - result of an regex operation
* *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)_ -
* _"metaoperator"{link: [perl 6 lookup tablet] metaoperators}_ - alters the meaning of other operators
* *Method* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl method
* *method* {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}_ - substitute with chars that has same mark/accent pattern as the matched string, short for *":samemark"{link: samemark}*
* *"mkdir"{link: [Perl 6 IO tablet] mkdir}* - creates a directory with given name
* *mod* _(numeric op)_ {section: mod} - integer modulo operator; wordy alias to *%*; e.q. '5 mod 4 = 1'
* *module* _(block modifier)_ - introduces a module name, a package that performs special actions on loading
* *"ms//"{link: [Perl 6 Regex Tablet] Matching}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - perform a regex based search in place, spaces are just subrule separators, alias to m:s/.../ or m:sigspace /.../
* *Mu* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ - 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, 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: N} - anything but (logical) newline
* *\n* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: n}- (logical) newline
* <n> *:nd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - demands the nth finding, has many aliases (:st :rd :th) for correct spelling (:2nd)
* *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* - creates a new object of a class, also name of the automatically called constructor method
* *NEXT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: NEXT} - marks a special block, executed at loop continuation time, before any *"leave"{link: LEAVE}*
* *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, similar to javas SUPER
* *Nil* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ -
* *none* _(junctive op)_ {section: none} - return true when a value is not part of a set, junctive NOT operator
* *normalize* - _(string method)_ {section: normalize} - normalize (repair) Unicode (UTF) string
* *not* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ {section: not} - logical NOT operator, returns _Bool::False_ if value is positive or _Bool::True_ if negates, low precedence version of *!*
* *"note"{link: [Perl 6 IO tablet] note}* - makes output via command line ($ERR) like *"warn"{link: warn}*, but appends a newline (\n) like *"say"{link: say}*
* *Num* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Num} - 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: O} - tests if file is owned by real uid
* *:o* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: o} - tests if file is owned by effective uid
* _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, eg _subset Month of Int where { 1 <= $^a <= 12 }_
* *one* {section: one} - junctive XOR operator
* *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 sequentially, ends evaluation at the first expression that returns true, low precedence version of *||*
* *ord* _(string method)_ {section: ord} - convert charakter into number according a character table, reverse of _char_
* *orelse* {section: orelse} - logical OR short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to *//*
* *our* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: our} - introduces "package"{link: P} - scoped names
* *:ov* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - searching at all positions just one time (with backtracking), short for ":overlap"
* *:overlap* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex 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}_ - 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}_ - quote paths and create path object that know the right format of the current {{$*OS with Q :p /.../}}, short for _:path_
* *:p*(<n>) _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - searching only on the nth (n is an int) position (counting from 0), short for ":pos"
* *:P5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - activate old Perl 5 regex rules, alias to :Perl5
* *"pack"{link: [Perl 6 Basics tablet] 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" and "class"
* *Pair* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - A single key-to-value association
* *PairSeq* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - A Seq of Pairs
* *pair* _(context op)_ - force pair context
* *pairs* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ - returns all contents as an array or pairs (key,value)
* *:panic* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - overwriting a possible set :ratchet for all subrules (activates backtracking)
* _Parameter_ - value passed to a method or subroutine, mostly as part of the signature
* *Parcel* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Arguments in a comma list
* *parcel* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ - raw reference, will not be contextualized
* *parsed* _"(routine trait)"{link: [perl 6 lookup tablet]routine traits}_ - this macro will be parsed once, it is hygienic, but own and later defined rules can't be applied, opposite of *reparsed*
* _Parsetree_ - hierarchical data representing the logical structure of a program
* *":path"{link: [Perl 6 Basics tablet] Paths}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - quote paths and create path object that know the right format of the current {{$*OS with Q :path /.../}}, long for _:p_
* *"perl"{link: [Perl 6 Basics tablet] perl}* _(formater)_ {section: perl} - transforms data structure into Perl 6 source syntax; use *eval* onto that string and you get the data structure again; bit like Data::Dump
* *:Perl5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - activate old Perl 5 regex rules, alias to :P5
* *pick* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pick} - select a number of random vaues (without duplication), take *roll* to enable duplication
* "phaser"{link: [perl_6_lookup_tablet] closure traits} - Perl 6 term for specially named subblocks withe special runtimes aka closure traits
* *pick* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - selects randomly elements from this list, optional parameter says how many
* _pipe_ - connection between 2 processes, move data (mostly only in one direction) without buffering
* _pointy block_ - a block that is given parameters with '->'
* *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}_ - searching only on the nth (n is an int) position (counting from 0), long for ":p"
* *POST* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: POST} - marks a special block, assert postcondition, executed at every block exit, after *"LEAVE"{link: LEAVE}*
* *postcircumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])
* *postfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that stay after a statement or variable (like $a++)
* *PRE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: PRE} - marks a special block, assert precondition, executed at every block entry, before *"ENTER"{link: ENTER}*
* *pred* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: pred} - returns the predecessor of $x (only parameter), alias to *--* operator; (see *"succ"{link: succ}*)
* *prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that stay before a statement or variable (like ++$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) without adding a newline, similar to *"say"{link: say}*
* *"print"{link: [Perl 6 IO tablet] print for files}* _(handle method)_ - writes a stream into a file
* *"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}*
* *"prompt"{link: [Perl 6 IO tablet] prompt}* {section: prompt} - *"print"{link: print}*-ing text and reading the answer (a line from $*IN- formerly _STDIN_)
* _property_ {section: property} - metadata 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
* *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*)

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

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

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

* *R*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - reverse operands
* *:R* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - check if file is readable by real uid/gid
* *:r* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - check if file is readable by effective uid/gid
* *\R* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - anything but return
* *\r* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - return (CR), as in Perl 5
* *rand* - pseudo random number in range 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}_ - A pair of ordered endpoints
* *RangeIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Iterator over a Range
* _Range Operator_ - written as '..' in scalar context defines set of possible values for smartmatch, in list context makes a list of successive values
* *Rat* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Perl rational (exact Real, limited denominator)
* *:ratchet* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - deactivates backtracking, search starts at pos, where last match ended
* <n> *:rd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd)
* *"read"{link: [Perl 6 IO tablet] read}* _(Buf method)_ - 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 {{[ ]}} "metaoperator"{link: [perl 6 lookup tablet] metaoperators}: {{ [+] @a = @a.reduce(&amp;[+]) }}
* _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} - builtin type that holds a compiled regular expression
* *regex* - (routine type) - a pattern definition (without :ratchet and :sigspace), can be put in a grammar, similar to qr/.../ in Perl 5
* *":regex"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - parse as quoted string as regex
* _Regular Expression_ - in Perl5: pattern matching notation, either regex, token or rule in Perl6
* *reparsed* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ - after parsing this *"macro"{link: macro}*, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of *"parsed"{link: parsed}*
* *"repeat"{link: [Perl 6 Block tablet] repeat}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: repeat} - initial command for *"while"{link: while}* or *"until"{link: until}* loops that have their condition at the end
* *"rename"{link: [Perl 6 IO tablet] rename}* {section: rename} - changes names of files and directories
* *return* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: return} - leaves a subroutine and sets the return value
* *returns* {section: returns} - sub trait describing the type of value produced by a function
* *reverse* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: reverse} - returns all the members in the opposite order. Use *"flip"{link: flip}* to turn a string back to front and *"invert"{link: invert}* for hashes
* *rindex* _(string method)_ {section: rindex} - finds the last occurrence of a substring in a string and returns the numerical position, opposite or *"index"{link: index}*
* *"rmdir"{link: [Perl 6 IO tablet] rmdir}* {section: rmdir} - deletes a directory with given name
* *role* {section: role} - container for methods that can extend a class using does
* *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 $x, Int $n) compute the $n'th root of $x
* *roundrobin* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - kind of zip that ignores empty values: _{{roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3}}_
* *Routine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Base class for all wrappable executable objects
* *rule* {section: rule} - alias for "regex :ratchet :sigspace" in a grammar, see regex, 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}* - executes an external program that replaces the caller, because there will be no return
* _Runtime_ - time when software is being used (not compiletime), or software components necessary for that, or length of time to execute
* *rw* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: rw} - marks a subroutine as returning an lvalue
* *rw* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ - mutable parameter (rw stands for: read write)
* *:rw* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - gives the regex the right to change the string (operand)
* *rx* _"(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: Q}* :regex // and *"regex"{link: regex}* _(block modificator)_

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

* *S*<op> _"(meta op)"{link: [Perl 6 lookup tablet] Metaoperators}_ - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism
* *"s///"{link: [Perl 6 Regex Tablet] Substitution}* _"(regex quoting op)"{link: [Perl 6 lookup tablet] Quoting Ops}_ - perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst // and *"subst"{link: subst}* _(block modificator)_
* *:S* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ - file is a socket
* *:s* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ - file has size greater than 0
* *:s* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ - demands evaluation of scalar variables, long form of ":scalar", included in "", qq and {{<<>>}}
* *:s* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ - whitespace separates now subregex and don't stand for spaces to look for, short for ":sigspace", mm// is alias to m:sigspace//
* *\S* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - anything but whitespace
* *\s* _"escape sequence"{link: [Perl 6 lookup tablet] Escape Sequences}_ - any whitespace character (\h or \v or \t)
* *:sameaccent* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - only for substitutions, replacing with chars that have the same accent pattern as the replaced, long for ":aa"
* *:samecase* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: samecase} - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for ":ii"
* *:samemark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: samemark} - 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}_ - smart space mapping for substitutions, long for ":ss", ss// is alias to s:samespace///, (ss/teh hsa/the has/;)
* *"say"{link: [Perl 6 IO tablet] say}* {section: say} - makes output via command line ($OUT) like "print"{link: print}*, but appends a newline ("\n")
* *"say"{link: [Perl 6 IO tablet] say for files}* _(handle method)_ - writes a stream into a file and appends "\n"
* *Scalar* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl scalar, variable that holds a single value
* *":scalar"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - demands evaluation of scalar variables, long form of ":s", included in "", qq and {{<<>>}}
* _Scope_ - the block of code within which an identifier is usable
* *seed* {section: seed} - initialize a random number generator, optionally with a value
* *Seq* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Seq} - A list of values (can be generated lazily)
* *SeqIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: SeqIter} - Iterator over a Seq
* *Set* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Set} - 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}_ - word to name the namespace for sigils, used to redifine them or define your own with a macro
* *Signature* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Function parameters (left-hand side of a binding), surrounded by round parentheses
* *signature* _(routine method)_ - returns a capture object with the signature of this routine
* *signature* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type
* *:sigspace* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - whitespace separates now subregex and don't stand for spaces to look for, long for for ":s", mm// is alias to m:sigspace//
* *sin* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - sine
* *":single"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q"
* *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 ~, such as $~Regex or $~MAIN (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_ - array parameter that receives all (slurps) all optional subroutine arguments
* *SoftRoutine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - A routine that is committed to staying mutable
* *special_variable* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - namespace to define and redefine 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} - performs rx based substitution, spaces are just subrule separators, alias to s:samespace/.../.../, e.g.: ss/teh hsa/the has/;
* *:ss* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for ":samespace"
* <n> *:st* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex 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} - 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}_ - A symbol table hash (package, module, class, lexpad, etc)
* *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)
* *Str* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Perl string (finite sequence of Unicode characters)
* _String_ - series of characters, text
* *Sub* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl subroutine object
* *"sub"{link: [Perl 6 Block tablet] sub}* _(block modifier)_ {section: sub} - defines a subroutine
* *Submethod* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl subroutine acting like a method
* *submethod* _(block modifier)_ - defines methods, not inherited by subclasses
* _Subroutine_ - block of code callable by name
* *subset* - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }
* *":subst"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - parse as "substitution regex"{link: [Perl 6 Regex Tablet] Substitution}
* *"subst"{link: [Perl 6 Regex Tablet] Substitution}* _(string method)_ {section: subst} - method alias to {{ s///, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/; }}
* *substr* _(string method)_ {section: substr} - the scalar substring function like in Perl 5
* *succ* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: succ} - returns the successor of $x (only parameter), alias to *++* operator (see *"pred"{link: pred}*)
* *supersede* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ - replaces definitions of an existing name, e.g. methods and attributes of a class/grammar

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

* *:t* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - filehandle is opened to a tty (terminal)
* *\T* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - anything but a tab
* *\t* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - 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}_ - tangent
* *temp* - defines variables as temporary, synonym for the Perl 5 _local_
* *term* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - 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}_ - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd)
* *tighter* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ - 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}_ - defines end marker for the following heredoc, :to is short for :heredoc
* *to-radians* {section: to-radians} - convert from $base (second parameter) to radians, opposite of *"from-radians"{link: from-radians}*
* *token* {section: token} - kind of regex :ratchet (no backtracking), part of a grammar
* _Topicalizer_ - every keyword that sets the $_ 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} - transliteration (as in Perl 5), translating some character in a string into others, alias to Q :trans ///
* _Trait_ - additional property of a variable, defined at compile time, see but
* *":trans"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - evals the quoted as "transliteration"{link: [Perl 6 Regex Tablet] Transliteration} aka tr /.../.../ aka .trans("..." => "...")
* *"trans"{link: [Perl 6 Regex Tablet] Transliteration}* _(string method)_ - method name for tr/// operation, $str.trans( %mapping ) equals $str ~~ tr/%"mapping.sort.keys/%mapping.sort.values/"<http://mapping.sort.keys/%mapping.sort.values/>;
* *triangle* _(list method)_ - alias to {{[\ ]}} "metaoperator"{link: [perl_6_lookup_tablet] metaoperators}: {{ [\+] @a = @a.triangle(&[+]) }}
* *true* {section: true} - boolean value aka Bool::True
* *true* _(op)_ - converts value into the boolean context, low precedence alternative to "?"
* *trusts* {section: trusts} - allows a class the acess to otherwised sealed namespaces
* _"Twigil"{link: [perl 6 lookup tablet] Twigils} - second(ary)_ Sigil indicating a special property of a variable
* *twigil* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - word to name the namespace for "twigils"{link: [Perl 6 Variable Tablet] Twigils}, used to redifine them or define your own with a macro

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

* *:u* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - report if file has setuid bit set
* *\U[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ - everything within the brackets is uppercase
* *uc* {section: uc} - make all string chars uppercase
* *ucfirst* {section: ucfirst} - make first char of a string uppercase
* *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}* queue
* *uniq* _(list method)_ {section: uniq} - only unique elements of a list
* *"unless"{link: [Perl 6 Block tablet] unless}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: unless} - flow control modifier, opposite of if, runs block if expression is false
* *"until"{link: [Perl 6 Block tablet] until}* _"(block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: until} - opposite of while, runs block repeatedly is long as expression is false
* *unwrap* {section: unwrap} - remove an enclosing subroutine (see *wrap*)
* *"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}_ - anything but vertical whitespace
* *\v* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ - vertical whitespace
* *value* _"(pair method)"{link: [Perl 6 Variable Tablet] Pair}_ {section: value} - gets value (second) value of a pair (opposite of *key*)
* *values* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: values} - returns an array of just the values

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

* *:W* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - check if file is writeable by real uid/gid
* *:w* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - 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}_ - split quoted string on words (on whitespaces), no quote protection, short form of ":words", used in qw//
* *\W* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - anything but a word character
* *\w* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - word character (Unicode alphanumeric plus "_")
* *"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} - 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"
* *WHAT* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHAT} - 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)
* *WHEN* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHEN} - (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 mathces against $_ (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} - autovivification of closures
* *WHERE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHERE} - memory address of the object
* *where* {section: where} - defines subtypes of data, eg _{{subset Month of Int where { 1 <= $^a <= 12 } }}_
* *WHICH* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHICH} - object ID (type)
* *"while"{link: [Perl 6 Block tablet] while}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: while} - flow control modifier runs block repeatedly as long as en expression is true
* *WHO* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHO} - package, that support that object, long name in string context
* *WHY* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHY} - (reserved for documentation)
* *will do* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ - block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition
* *":words"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - split quoted string on words (on whitespaces), no quote protection, long form of ":w", used in qw//
* *words* _(string method)_ - splits a sting into a list of words, {{ $input.words($limit) equals $input.comb( / \S+ /, $limit ) }},
* *wrap* {section: wrap} - creates enveloping subroutine
* *"write"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: write} - writes content of all parameter into that buffer
* *":ww"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and "..." sourrounded strings are taken as single words), short form of *:quotewords*, used in << ... >>

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

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

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

* _yadda operator_ - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: *...*, *???* and *!!!*

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

* *Z* _(list op)_ {section: Z} - alias to zip _(list op)_ , joines 2 lists eg 1,2,3,4 Z 8,9 == 1,8,2,9
* *Z*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - 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 _{{ @a Z @b = (@a; @b).zip }}_
* *zipwith* _(list method)_ {section: zipwith} - alias to *Z* metaoperator: _{{ @a Z~ @b = (@a; @b).zipwith(&amp;[~]) = (@a; @b).zip.slice.map { .reduce(&amp;[~]) } }}_

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

----

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

----


Upload Files

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

Maximum file size: 50MB

 
 
 
File Name Author Date Uploaded Size

Save Page As

Enter a meaningful and distinctive title for your page.

Page Title:

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

Page Already Exists

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

Save with a different name:

Save the page with the name "XXX"

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

Upload Files

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

 
 
 
Add Tags

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

Tag: 

Suggestions: