Perl 6

Perl 6 Index Tablet: Revision 195

"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 binary context, high precedence version of *not*
* *!* _"(twigil)"{link: [Perl 6 lookup tablet] Twigils}_ - twigil of private class and object variables
* *!* - suffix for required named parameter in signatures
* *!*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ - negates (mostly comparsion operators)
* *!!* - second Part of the ternary (conditional) operator after ??
* *!!!* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ - yadda Operator that calles *die*
* *"" ""{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - double quoting, interpolate 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 _"(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 end of the line or bracket, works with any combination of bracket pairs
* *"$"{link: [perl 6 Variable Tablet] Scalar}* _"(sigil)"{link: [Perl 6 lookup tablet] Sigils}_ - prefix of "scalar vars"{link: [perl 6 Variable Tablet] Scalar}
* *$()* _"(conext op)"{link: [perl 6 lookup tablet]Contextualizers}_ - forces scalar context, alias to *item()*
* *$* _"(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
* *%()* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces hash context, alias to the *hash()* function
* *%%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - Bool::True if the left is evenly divisible by right value
* *"&"{link: [perl 6 Variable Tablet] Callable}* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - sigil of the callable namespace
* *&* _"(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 returned 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 ' needs o be quoted, alias to 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 and forces numeric context on parameters;
* *{{*}}* _(term)_ - synonym for Inf (Whatever) in connection with a Range operator (".."); marks the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element
* *{{*}}* - marks as prefix slurpy arrays in signatures
* *{{*}}* _"(twigil)"{link: [perl 6 lookup tablet] Twigils}_ - secondary sigil of global variables
* *{{**}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - raises a number to a power and forces numeric context
* *{{**}}* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - multiplies char or group like x _(strig op)_ outside of regex, (ha)**3 equals (hahaha)
* *+* _"(conext op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - forces numeric context of values and adds results
* *+&* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - bitwise and, numeric context
* *++* _(prefix & suffix op)_ - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to *succ*
* *+<* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - shift left in numeric kontext
* *+>* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - shift right in numeric kontext
* *+^* _"(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}_ - forces numeric context and subtract
* *--* _(prefix & suffix op)_ - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term, alias to *pred*
* *-->* - alternative syntax to type a parameter
* *{{->}}* - assigns a named parameter for a block (pointy block)
* *.* - secondary sigil for public accessors (getter/setter)
* *.* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ - really any character (unlike Perl 5)
* *..* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ - range generating operator, range object in "item context"{link: [perl 6 lookup tablet]Contextualizers}
* *...* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ - 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}_ - division, numeric context
* */* _"(rat composer)"{link: [Perl 6 Basics Tablet] Rational Number}_ - inside round braces (3/7) gives you a rational number that keeps track of its numerator and denominator
* *//* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ - short circuit _defined or_, returns the first defined value (from left to right), similar to *orelse*, high precedence version of *err*
* *{{\0[<n>]}}* _"escape sequence"{link: [perl 6 lookup tablet] Escape Sequences}_ - character given in octal (brackets optional)
* *:* - pair generation operator, also known as adverbial syntax
* *:* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - start of all file text ops, syntax: {{":"}} ~ 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}_ - for 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 65
* *:* - (flow control) - endchar of all labels, "jou can jump to"{link: [Perl 6 Block Tablet] goto}
* *:* - prefix of named parameter in a signature
* *::* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ - abstraction sigil, name space separator (like in Perl 5)
* *"::="{link: [Perl 6 Variable Tablet] Binding}* - "binding"{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}* - seperates commands ( "statements"{link: [Perl 6 Basics Tablet] Statements} ) or "array indices"{link: [Perl 6 Variable Tablet] Array Slices} eg {{@[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) - ternary or conditional operator
* *???* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ - yadda operator that calles *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
* *^* - 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}_ - 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) - 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

* *: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)_ - 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*, 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* - junctive OR operator
* *arity* _(routine method)_ - returns how many parameters this routine requires, take *.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* _"(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

* *: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)"{}_ - 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}_ - leave this when clause block now
* *Buf* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl buffer (a stringish array of memory locations)
* *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

* *: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* - 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}_ - coverts 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
* *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)_ - 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* - 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)_ - 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
* *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)_ - declares a collection of methods that define an object
* *classify* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - special form of map, to classify input values; the return value of the closure determines, under which key the value appears in the resulting hash
* *"close"{link: [Perl 6 IO tablet] Files}* _(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}_ - general comparator, result: -1(lower than), 0 (equal), 1 (greater than), using the _Order_ class
* *Code* - data typ for code references of any kind {section: co}
* *: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)_ - $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
* *Cool* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ - Perl 6 Convenient OO Loopbacks,
* *copy* _"(parameter trait)"{link: [Perl 6 lookup tablet] parameter traits}_ - read-writable copy of the original argument ("pass-by-value")
* *count* _(routine method)_ - returns how many parameters this routine takes (including optional), *.arity* counts just the required
* *cross* _(list method)_ - alias to X operator: {{ @a X @b = (@a; @b).cross }}
* *crosswith* _(list method)_ - alias to X metaoperator: {{ @a X~ @b = (@a; @b).crosswith(&[~]) = (@a; @b).cross.slice.map { .reduce(&[~]) } }}
* _Currying_ - creating a subroutine as a derivate from another with certain parameter to be predefined

^^ 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
* *"default"{link: [Perl 6 Block tablet] default}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ - 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)_ -
* *defined* - scalar method tests whether a value has been assigned to a variable
* *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* - throws a fatal Exception, the default exception handler prints each element of the list to $*ERR (STDERR)
* *"dir"{link: [Perl 6 IO tablet] Directories}* - returns all files of a given directory, excluding . and .. by default
* *div* - division, creates fraction objects in Integer context
* *"do"{link: [Perl 6 Block tablet] 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

* *: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* - variant of all() that promises to do things in order, is Positional/Iterable
* *eager* - forces eager evaluation (now), default for scalars
* *elems* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - returns number of elements
* *"else"{link: [Perl 6 Block tablet] else}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ - introduces the alternative block after an 'if' or 'elsif'
* *"elsif"{link: [Perl 6 Block tablet] elsif}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ - alternative if clause
* *END* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - marks a special block, executed at run time, ALAP, only ever runs once
* *ENTER* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - 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}_ - An immutable Pair
* *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}_ - infix operator, proves equality in forced string context
* *equiv* _"(routine trait)"{link: [Perl 6 Lookup Tablet]Routine Traits}_ - specifies the "precedence of an operator"{link: [Perl 6 lookup tablet]Table of Precedence} same as an existing operator
* *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}_ - short circuit defined or, returns the first defined value from the left, short circuit or,low precedence version of *//*
* *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* - 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*) 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* - checks for existence of a variable or hash member, scalar method
* *exit* - stops all program execution, and returns Int $status (first parameter) to the calling environment
* *exp* - alias method to $base (first parameter) ** $exponent (second parameter - defaults to e)
* *export* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ - this routine will be exported my the current module by default

^^ F

* *:f* _"(filetest op)"{link: [Perl 6 Lookup Tablet]Filetest Ops}_ - 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* - 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}_ - data type object for an error, thrown by an unhandled exception
* *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}* - flip flop operator in the style of awk, formerly .. in scalar context
* *"fff"{link: [Perl 6 Operator tablet]flipflop}* - 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
* *flat* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ - forces flat list context, opposite of *lol()*
* *flip* _(string method)_ - reverses order of characters in strings
* *"fmt"{link: [Perl 6 Basics tablet] fmt}* - method on a scalar, takes a format specifier returns a string, simplified version of *sprintf*
* *"for"{link: [Perl 6 Block tablet] for}* _"(loop block modifier)"{link: [Perl 6 lookup tablet]Loops}_ - only iterates over a list
* *"fork"{link: [Perl 6 IO Tablet] Processes}* - 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* - convert from radians to $base (second parameter), opposite of *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

* *:g* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ - 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
* *"gather"{link: [Perl 6 Block Tablet ]gather and take}* _(block modifier)_ - performs the following block once, returns a list of all values passed by *take*
* *ge* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ - infix operator, greater than on equal
* *"get"{link: [Perl 6 IO tablet] Files}* _(handle method)_ - 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] Files}* _(handle method)_ - reads ones character from a file via file handle
* *"given"{link: [Perl 6 Block tablet] given}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ - case construct puts a value into the context variable for when clauses
* *:global* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - 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}_ - transfer execution to a defined label
* *grammar* - special kind of class to hold regex token and rule definitions
* *:graphs* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
* *grep* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - gives all values of an array that pass a filters condition
* *gt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ - infix operator, greater than or equal, Bool::True if alphabetically ordered the right comes before the left

^^ 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}_ - 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* - forces none-lazy list context, that ignores the order of results (allowes parallel computing)

^^ 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}_ - flow control conditional statement or block modifier, executes code only when a condition expression evaluates to true
* *: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"
* *index* _(string method)_ - 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}_ - 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.)
* *int* - extract a whole number value, discarding fractional part
* *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* - 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

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

^^ 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}_ - marks a special block, executed at every successful block exit, part of 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}_ - 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}_ - returns list of hash keys
* *"kill"{link: [Perl 6 IO Tablet] Processes}* - 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}_ - returns list of key-value pairs

^^ 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}_ - marks a special block, executed at loop termination time, after any LEAVE
* *last* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ - 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)_ - make string lowercase
* *lcfirst* _(string op & method)_ - make first char of a string lowercase
* *le* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ - infix operator, lower than or equal, (see lt, gt, ge)
* *LEAVE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - 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}_ - exit the current block with a return value
* *leg* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparsion}_ - infix operator, lower/equal/greater comparator, does *cmp* in string context as {{<=>}} does in numerical context, was cmp in P5
* *let* - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully
* *lines* _(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] Files}* _(path 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* - 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}_ - 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}_ - infix operator, lower than, Bool::True if alphabetically ordered the left comes before the right

^^ 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)_ - 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}_ - 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* - defines a method (inheritable routine) in a class
* *min* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - returns the numerically smallest value from a given list
* *minmax* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - 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"
* *"mkdir"{link: [Perl 6 IO tablet] Directories}* - creates a directory with given name
* *mod* _(numeric op)_ - generic modulo operator
* *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}_ - 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}_ - introduces lexically scoped names, which exists only in the current scope (usually a block)

^^ N

* *\N* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ - anything but (logical) newline
* *\n* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ - (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)_ - returns the name of of a routine, handy when it was stored in a scalar
* *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}_ - marks a special block, executed at loop continuation time, before any LEAVE
* *next* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ - start the the next following loop iteration
* *nextsame* - get from the dispatcher the next candidate with the same signature, similar to javas SUPER
* *none* - return true when a value is not part of a set, junctive NOT operator
* *normalize* - _(string method)_ - normalize (repair) Unicode (UTF) string
* *not* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ - 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] Command Line}* - makes output via command line ($ERR) like *warn*, but appends a newline (\n) like *say*
* *Num* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - Perl number (approximate Real, generally via floating point)
* *numerator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ - returns the numerator of a rational number (value type Rat and FatRat)

^^ O

* *:O* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - tests if file is owned by real uid
* *:o* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ - 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}_ - inner type constraint that a routine imposes on its return value, eg subset Month of Int where { 1 <= $^a <= 12 }
* *one* - junctive XOR operator
* *only* _"routine modifier"{link: [perl 6 lookup tablet] routine modifier}_ - permits only one routine of the same name in this block
* *"open"{link: [Perl 6 IO tablet] Files}* _(filehandle method)_ - establishes a connection to a file via a file handler
* *or* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ - short circuit OR, evaluates sequentially, ends evaluation at the first expression that returns true, low precedence version of *||*
* *ord* _(string method)_ - convert charakter into number according a character table, reverse of _char_
* *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}_ - 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

* *: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)_ - 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}* - evaluates the following string or content of the var on which is called this method, functions with "say" like a better Data::Dumper
* *: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}_ - 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}_ - 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}_ - marks a special block, assert postcondition, executed at every block exit, after 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}_ - marks a special block, assert precondition, executed at every block entry, before ENTER
* *pred* - returns the predecessor of $x (only parameter), alias to *--* operator
* *prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ - operator namespace of ops, that stay before a statement or variable (like ++$a)
* *"print"{link: [Perl 6 IO tablet] Command Line}* - sends characters to an output stream ($OUT) without adding a newline, similar to *say*
* *"print"{link: [Perl 6 IO tablet] Files}* _(handle method)_ - writes a stream into a file
* *"printf"{link: [Perl 6 IO tablet] Command Line}* - formats text like *sprintf* and sends it to standard output like *print*
* *"prompt"{link: [Perl 6 IO tablet] Command Line}* - "print"ing text and reading the answer (a line from $*IN - formerly STDIN)
* _property_ - metadata set at runtime
* *proto* _"(routine modifier)"{link: [perl 6 lookup tablet] routine modifier}_ - 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}_ - appends a list of values to the end of an array

^^ Q

* *"Q"{link: [Perl 6 Basics tablet] Quoting}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - 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}_ - 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

* *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* and *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)
* *readline* - now called 'get', reads from an input stream until the next newline
* *readonly* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ - immutable parameter
* *redo* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ - re-starts processing of the current loop turn
* *reduce* _(list method)_ - alias to {{[ ]}} "metaoperator"{link: [perl 6 lookup tablet] metaoperators}: {{ [+] @a = @a.reduce(&[+]) }}
* _Reference_ - address of data in memory, often termed a Capture in Perl 6
* *Regex* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Perl pattern
* *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, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of "parsed"
* *"repeat"{link: [Perl 6 Block tablet] repeat}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ - initial command for while or until loops that have their condtion at the end
* *"rename"{link: [Perl 6 IO tablet] Directories}* - changes names of files and directories
* *return* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ - leaves a subroutine and sets the return value
* *returns* - sub trait describing the type of value produced by a function
* *reverse* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - returns all the members in the opposite order. Use "flip" to turn a string back to front and "invert" for hashes
* *rindex* _(string method)_ - finds the last occurrence of a substring in a string and returns the numerical position, opposite or _index_
* *"rmdir"{link: [Perl 6 IO tablet] Directories}* - deletes a directory with given name
* *role* - container for methods that can extend a class using does
* *roll* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ - selects $n (first parameter) values from an array, duplication can occur (like rolling dice), *pick* works without duplication
* *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* - alias for "regex :ratchet :sigspace" in a grammar, see regex, token
* *"run"{link: [Perl 6 IO Tablet] Processes}* - 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}_ - 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}_ - creates anonymous regex, that can me then assigned into a var, alias to Q :regex // and regex _(block modificator)_

^^ 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* _(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}_ - 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}_ - 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] Command Line}* - makes output via command line ($*OUT) like print, but appends a newline ("\n")
* *"say"{link: [Perl 6 IO tablet] 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* - initialize a random number generator, optionally with a value
* *Seq* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - A list of values (can be generated lazily)
* *SeqIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ - Iterator over a Seq
* *Set* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ - unordered collection of values that allows no duplicates
* *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//
* *":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* - attempt to sleep for up to Num $for seconds (with sub-second resolution)
* _slice_ - part of an array or list
* *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 method)_ - 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}_ - remove on $pos (first parameter) $n (second - optional) values and replace them with values (third - optional)
* *split* - makes an array of substrings from a string and a separator
* *"sprintf"{link: [Perl 6 Basics tablet] sprintf}* - inserts formated values out of variables into a string like printf, but returns the string instead of outputting it
* *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}_ - 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}_ - 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}_ - 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)_ - 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)_ - method alias to s///, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/;
* *substr* _(string method)_ - the scalar substring function like in Perl 5
* *succ* - returns the successor of $x (only parameter), alias to *++* operator
* *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

* *: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}* - can add several item to the list of return values of a *gather* block
* *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* - convert from $base (second parameter) to radians, opposite of *from-radians*
* *token* - kind of regex :ratchet (no backtracking), part of a grammar
* _Topicalizer_ - every keyword that sets the $_ variable, eg given, for
* *touch* (filehandle method) - update timestamps on a file
* *"tr///"{link: [Perl 6 Regex Tablet] Transliteration}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ - 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/;
* *triangle* _(list method)_ - alias to {{[\ ]}} "metaoperator"{link: [perl_6_lookup_tablet] metaoperators}: {{ [\+] @a = @a.triangle(&[+]) }}
* *true* _(term)_ - converts value into the boolean context, low precedence alternative to "?"
* *true* - boolean value aka Bool::True
* *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

* *: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* - make all string chars uppercase
* *ucfirst* - make first char of a string uppercase
* *UNDO* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ - marks a special block, executed at every unsuccessful block exit, part of LEAVE queue
* *"unless"{link: [Perl 6 Block tablet] unless}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ - 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}_ - opposite of while, runs block repeatedly is long as expression is false
* *unwrap* - remove an enclosing subroutine
* *"use"{link: [Perl 6 Subroutine tablet] }* - load a module, import definitions, check Perl version

^^ 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}_ - gets value (second) value of a pair
* *values* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ - returns an array of just the values

^^ 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}* - waits for a child process to terminate and returns the child status object, process ID in numeric context
* *want* - produces a signature object that provides information about the context from which the current routine was called
* *"warn"{link: [Perl 6 IO tablet] Command Line}* - makes output via standart error output ($ERR - usually the command line), similar to *note*, but works more like *print*, without appending "\n"
* *WHAT* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - short name of the class that an object belongs to
* *Whatever* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch)
* *WHEN* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - (reserved for events?)
* *WHENCE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - autovivification of closures
* *"when"{link: [Perl 6 Block tablet] when}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ - executes its code block if a 'given' value smartmatches
* *WHERE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - memory address of the object
* *where* - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 }_
* *WHICH* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - object ID (type)
* *"while"{link: [Perl 6 Block tablet] while}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ - flow control modifier runs block repeatedly as long as en expression is true
* *WHO* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - package, that support that object, long name in string context
* *WHY* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ - (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)_ - returns a list of words (chunks of alphanumeric character) containing a string, {{ $input.words($limit) equals $input.comb( / \S+ /, $limit ) }}
* *wrap* - creates enveloping subroutine
* *":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

* *X* _(list op)_ - Cross product of two arrays, eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 ; alias of comb method
* *x* _"(string op)"{link: [perl 6 Operator tablet] String Context}_ - 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>
* *: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*) 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}_ - infix logical exclusive or operator, in boolean context true if only one side has positive value, returns otherwise left value, low precedence version of *^^*
* *xx* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ - replicate a list _$n_ (second operand) times, eg 'ab' xx 3 == <ab ab ab>

^^ Y

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

^^ Z

* *Z* _(list op)_ - 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}_ - zip operator, joines 2 lists, alias to Z operator {{ @a Z @b = (@a; @b).zip }}
* *zipwith* _(list method)_ - alias to Z metaoperator: {{ @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) } }}

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

----

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

----