Perl 6
Perl 6 Index Tablet: Compare Revisions 72 and 433
Revision 72by Herbert Breunung
|
Revision 433by Herbert Breunung
|
|
"Overview"[Perl 6 Tablets] - _Chapter:_ "0:Intr"[Perl 6 Intro Tablet], "1:Hist"[Perl 6 History Tablet], "2:Design"[Perl 6 Language Design 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] - _Appendices:_ *"A:Index"[Perl 6 Index Tablet]*, "B:Tables"[Perl 6 Lookup Tablet], "C:Best of"[Best Of Perl 6 Tablet], "D:Delta"[Perl 6 Delta Tablet], "E:Links"[Perl 6 Links Tablet] |
{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} | {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. |
This index contains an alphanumeric sorted list (sorted without prefixes like colon, slash, sigil or twigil) of all operators, methods, builtins, options, modifier and special variables *(bold)* and some technical terms _(italic)_ with short explanations. Each bold term is followed by a link (in round braces) to a condensed summary listing of its category in appendix B. Sometimes are added placeholder for parameter in angle brackets. _<n>_ stands for a integer number, _<f>_ is a floating point number, _<s>_ string, _<var>_ any variable, _<op>_ any operator and _<p>_ for a regex pattern. |
|
* *!* - logical negation, forces binary context; * *!* "(twigil)"{link: [perl_6_lookup_tablet] Twigils} - twigil of private class and object variables * *!*<op> "(meta op)"{link: [perl_6_lookup_tablet] Metaoperators} - negates (mostly comparsion operators) * *!!* - second Part of the ternary (conditional) operator after ?? * *!!!* (yadda op) - yadda Operator that calles die * *{{""}}* "(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//* * *#* - starts a comment that continues to the end of the line or bracket; works even inside regexes as "(regex Metachar)"{link: [perl_6_lookup_tablet] Regex Metacharacter} * *$* "(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 *scalar()* * *$* "(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} * *%* - 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 * *%%* - Bool::True if the left is evenly divisible by right value * *&* "(sigil)"{link: [perl_6_lookup_tablet] Sigils} - sigil of coderefs * *&* - 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 and, conditonal statements, ends evaluation on the first false expression, returns boolean result * *''* "(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 * *{{*}}* _(scalar num op)_ - 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 * *{{**}}* _(scalar num op)_ - 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 _(scalar strig op)_ outside of regex, (ha)**3 equals (hahaha) * *+* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers}, (scalar num op) - forces numeric context of values and adds results * *+&* _(scalar num op)_ - 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 * *+<* _(scalar num op)_ - shift left in numeric kontext * *+>* _(scalar num op)_ - shift right in numeric kontext * *+^* _(scalar num op)_ - bitwise xor in numeric context * *+|* _(scalar num op)_ - bitwise or in numeric context * *,* - list generating operator * *{{-}}* - 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 * *-->* - 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) * *..* - range generating operator; range object in scalar context, see smartmatch table * *...* (yadda op) - yadda Operator that calles fail (exception) * */* - division, numeric context * *//* - returns the first defined value, similar to *orelse* * *{{\0[<n>]}}* "escape sequence";{link: [perl_6_lookup_tablet] Escape Sequences} - character given in octal (brackets optional) * *:* - pair generation operator * *:* "(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>* - makes a number n in base b (up to 36), for example :2<1000001> is 65 * *:* - marks as prefix named parameter in a signature * *:* - (flow control) - endchar of all labels, jou can jump to (see also goto) * *::* "(sigil)"{link: [perl_6_lookup_tablet] Sigils} - abstraction sigil, name space separator (like in Perl 5) * *::=* - binding a value or variable to a variable at compile time * *:=* - creates an alias to a variable at runtime (binding) * *;* - seperates commands (statements) or array indices eg {{@[2;3] instead of @a[2][3]}} * *<* - less than, numeric comparison operator * *<;>* 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) * *<<>>* "(quoting op)"{link: [perl_6_lookup_tablet] Quoting Ops} - circumfix quoting operator for grouping with autoquoting and evaluation (alias to Q :qq :ww /.../) * *<=* - less than or equal, numeric comparison operator * *<==* - leftward pointing feed operator * *<;=>;* - numeric less-equal-greater comparison for Order class * *<>* "(quoting op)";{link: [perl_6_lookup_tablet] Quoting Ops} - circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../) * *<>* "(regex Metachar)"{link: [perl_6_lookup_tablet] Regex Metacharacter} - embraces an subrule (assertion) * *=* _(Op)_ - assignment, left side is evaluated and assigned to the right * *{{<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) * *=:=* _(Op)_ - compares binding, if both vars are bound to same memory location * *==* _(Op)_ - equality of value (numeric) * *===* _(Op)_ - 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_ * *>* _(Op)_ - greater than, numeric comparison operator; ends grouping with autoquoting (formerly qw()) * *>=* _(Op)_ - greater than or equal, numeric comparison Op * *>>* "(meta op)"{link: [perl_6_lookup_tablet] Metaoperators} - binds operator (right) as hyper operator to an array (left) * *?* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers} - forces binary context in an expression * *?* - marks as postfix optional 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 * *?&* - logical op, and combinator, forces binary context * *?? !!* - ternary or conditional operator * *???* (yadda op) - yadda operator that calles warn * *?^* - logical xor, forces operands into boolean 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 *array()* function * *@@()* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers} - forces slice context, meaning an array that may contain array references (not flattened), alias to *slice()* 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 * *[]* "(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 operator, 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 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)_ - start of the string * *^^* - logical xor, combines expressions, returns true when only one expression is true, otherwise false * *^^* _(regex Metachar)_ - 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) - 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 object into arglist * *||* - logical or, evaluates sequentially, ends evaluation at the first expression that returns true * *||()* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers} - flatten capture object into semicolon list * *~* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers}, (scalar string op) - forces string context (stringify) and/or concatenate strings, synonym for cat * *~&* - characterwise and, forces string context * *~<* - characterwise left shift, forces string context * *~>* - characterwise right shift, forces string context * *~^* - characterwise xor, forces string context * *~|* - characterwise or, forces string context * *~~* - smartmatch operator, compares (almost) all data types |
Before alpha chars (a-z) come the other in ASCII order: *"!"#"{link: exclamation mark}* *"$%&"{link: dollar sign}* *"'(*"{link: single quotation marks}* *"+,-"{link: plus sign}* *"./0"{link: dot}* *":;<"{link: colon}* *"=>;?"{link: equal sign}* *"@[\"{link: at sigil}* *"^_{"{link: caret}* *"|~"{link: pipe op}* |
|
^^ A |
* *!* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ {section: exclamation mark} {section: exclamation mark op} - logical negation (_NOT_), forces boolean context (is a _"contextualizer"{link: contextualizer}_), high precedence version of *"not"{link: not}* * *!* _"(var twigil)"{link: [Perl 6 lookup tablet] Twigils}_ {section: exclamation mark twigil} - _"twigil"{link: twigil}_ of private class and object variables * *!* _(signature symbol)_ {section: exclamation mark signature} - "suffix"{link: suffix category} for a required parameter in signatures * *!*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: exclamation mark metaop} - negates (mostly "comparison operators"{link: [perl 6 Operator tablet] Comparison} ) * *$!* - _"(special var)"{link: [perl 6 lookup tablet] Special Variables}_ {section: exclamation mark var} - last error message * *<!>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: exclamation mark subrule} - inverse of *"<?>"{link: question mark subrule}*, returns always false * *!!* {section: exclamation mark exclamation mark } - just second part of the ternary (conditional) operator after *"??"{link: ??}*, no op on its own * *!!!* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple exclamation mark} - yadda operator that calls *"die"{link: die}* * *"" ""{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: double quotation marks} - double quoting, interpolates with *":s"{link: s adverb}*, *":a"{link: a adverb}*, *":h"{link: h adverb}*, *":f"{link: f adverb}*, *":c"{link: c adverb}*, *":b"{link: b adverb}* (all vars, functions, blocks, control chars), alias to *"qq/.../"{link: qq op}* or *Q* *":qq"{link: qq adverb}* */.../* * *"#"{link: [Perl 6 Basics Tablet]Single Line}* {section: pound} - starts a comment that continues to the end of the line; works even inside regexes as a _"regex metachar"{link: [perl 6 lookup tablet] Regex Metacharacter}_ * *"#="{link: [Perl 6 Basics Tablet] POD}* {section: pound equal} - starts comments to the lineending like *#*, just makes documenting comments that end up in _&routine.WHY.content_ on the following _"routine"{link: routine}_ * *"#`( )"{link: [Perl 6 Basics Tablet] Multi Line}* {section: pound apostrophe} - starts a multi-line comment that continues to the closing bracket, works with any combination of bracket pairs * *"$"{link: [perl 6 Variable Tablet] Scalar}* _"(sigil)"{link: [Perl 6 lookup tablet] Sigils}_ {section: dollar sign} {section: dollar sigil} - "prefix"{link: prefix category} of "scalar variables"{link: [perl 6 Variable Tablet] Scalar} * *$*() _"(context op)"{link: [perl 6 lookup tablet]Contextualizers}_ {section: dollar context op} - forces scalar context, alias to the *"item()"{link: item}* function * *$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dollar metachar} - end of the string * *$$* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dollar dollar } - end of a line * *%* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: percent sigil} - "prefix"{link: prefix category} of "hash variables"{link: [perl 6 Variable Tablet] Hash} * *%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: percent} - gives remainder of a modulo division, forces numeric context * *%*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: percent context op} - forces hash context, alias to the *"hash()"{link: hash}* function * *%*<s> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: percent metachar} - quantifier that repeat char or group as long as separated by right expression - example: `\d % ','` matches `1,2,3,4,5` * *%%* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: percent percent } - *"True"{link: true}* if the left value is evenly divisible by the right value * *%%*<s> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: percent percent metaop} - quantifier that repeat char or group as long as separated by right expression like %. but allows trailing separator - example: `\d %% ','` matches `1,2,3,4,5,` * *"&"{link: [perl 6 Variable Tablet] Callable}* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: - _"sigil"{link: ampersand sigil} _ of "callable variables"{link: [perl 6 Variable Tablet] Callable} like "subs"{link: sub}, "methods"{link: method} and other "blocks"{link: block} * *&* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: junctive and} {section: ampersand op} - junctive _AND_, requires that all conditions are met, see also: *"all"{link: all}* * *&* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: ampersand metachar} - match multiple patterns (_AND_-connection of patterns) * *&&* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: high and} {section: ampersand ampersand} - short circuit _AND_, evals right side if left side returns *"True"{link: true}*, high precedence version of *"and"{link: and}* * *"' '"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: single quotation marks} - simple quoting, just / and ' must be escaped, alias to *"q/.../"{link: q op}* or *Q :q/.../* * *()* {section: round brackets } - grouping of values (parameters) * *()* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: round brackets metachar } - encompass a _subregex_ / _submatch_ , results land in *"@()"{link: round brackets var}* or *"$0"{link: 0 var}*... (not limited to $9 anymore) * *@()* - _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: round brackets var} - holds positional submatches, *{{$()[n]}}* is alias to *"$/[n]"{link: match var}* and *"$n"{link: 0 var}* * *{{*}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: asterisk op} - multiplies numbers, forces numeric context * *{{*}}* _(term)_ {section: asterisk} - synonym for *"Whatever"{link: Whatever}*, for example, means `Inf` in a "range operator"{link: range op} (*..*), means the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element * *{{*}}* _(signature symbol)_ {section: asterisk signature} - "prefix"{link: prefix category} which indicates _slurpy_ arrays in signatures * *{{*}}* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: asterisk twigil} - _"twigil"{link: twigil}_ of global variables * *{{*}}* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk metachar} - quantifier for zero or more findings * *{{**}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: asterisk asterisk op} - raises a number to a power, forces numeric context * *{{**}}* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk asterisk op} - not backtracking, greedy quantifier taking zero or more findings * *{{**}}*<n> _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: asterisk asterisk metaop} - quantifier for explicit repeat char or group, like *"x"{link: x}* _(string op)_ does outside of a regex; for example, `(ha)**3` matches `(hahaha)` * *+* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus sign} {section: plus op} - "infix"{link: infix category} addition operator, forces "numeric context"{link: numeric context} * *+* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: plus metachar} - quantifier for one or more findings * *+&* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus ampersand} - bitwise _AND_, forces numeric context * *++* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: plus plus} {section: double plus} - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the "evaluation"{link: evaluation} of the surrounding term, alias to *"succ"{link: succ}* * *+<* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus lower} - shift left in numeric context * *+>* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus greater} - shift right in numeric context * *+^* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus caret} - bitwise _XOR_ in numeric context * *+|* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: plus pipe} - bitwise _OR_ in numeric context * *","{link: [perl 6 Variable Tablet] Array}* {section: comma} - "list"{link: [perl 6 Variable Tablet] Array}-generating operator * *{{-}}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: minus op} - "infix"{link: infix category} subtraction operator, forces numeric context (and negates) * *--* _"(sequence traversal)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: minus minus op} - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the "evaluation"{link: evaluation} of the surrounding term, alias to *"pred"{link: pred}* * *-->* _(signature symbol)_ {section: minus minus greater signature} - declares the type of the return value of a routine, type name is placed after this arrow at the end of a signature * *{{->}}* _(signature symbol)_ {section: minus greater} {section: arrow op} - declares named parameters for a block (pointy block) * *.* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: dot} {section: dot twigil} - _"twigil"{link: twigil}_ of public accessors (getter/setter) * *.* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: dot metachar} - matches any character (including a newline, unlike in Perl 5) * *..* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_, _"(list op)"{link: [perl 6 Operator tablet] List generation}_ {section: range op} {section: dot dot} - "infix"{link: infix category} range generating operator, produces a `Range` object in "item context"{link: [perl 6 lookup tablet]Contextualizers} * *"..."{link: [perl 6 Operator tablet] Sequence Operator}* _"(list op)"{link: [perl 6 Operator tablet] List generation}_ {section: triple dot op} - "infix"{link: infix category} sequence generating operator, infix operator for list generation * *...* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple dot yadda op} - term that calls *"fail"{link: fail}* (exception), marks unimplemented empty routine bodies * */* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: slash} {section: slash op} - divides numbers, forces numeric context * */* _"(rat composer)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: slash rat op} - inside round 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 * *$/* - _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: slash var} {section: match var} - last created match object of this block * *//* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: high err} {section: slash slash op} - short circuit _defined or_, returns the first defined value (from left to right), similar to *"||"{link: pipe pipe op}*, high precedence version of *"err"{link: err}* * *{{\0}}*_B_*{{[<n>]}}* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash 0} - character given in octal, decimal or hex (when _B_ is 'o', 'd' or 'x'), brackets are optional, first number has to be inside okt/dec/hex range, alternate syntax without the zero is preferred * *{{$0}}* _"(special var)"{link: [perl 6 lookup tablet] Match Variables}_ {section: 0 var} - first positional submatch, there is *$1*, *$2*, ... too (don't stops at *$9* like Perl 5), alias to *"$()[0]"{link: braces var}* and *"$/[0]"{link: backslash var}*, former $0 is now *"$*EXECUTABLE_NAME"{link: EXECUTABLE NAME global var}* * *:* {section: colon} - _"pair"{link: [perl 6 variable tablet] pair}_ generation operator, also known as _adverbial_ syntax * *:* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: colon filetest} - start of all file test ops - example: _{{":"}} ~ one (<r w x o R W X O e z s f d l p S b c t u g k T B M A C>)_ * *:* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: colon twigil} - _"twigil"{link: twigil}_ of autogenerated named parameters of a block * *:*_B_*<N>* {section: colon number} - "general radix form"{link: [Perl 6 Basics Tablet]General Radix Form} for literals, makes a number N in base B (up to 36) - example: `:2<1000001>` is decimal 65 * *:*<s> _(flow control)_ {section: colon label} - suffix of all labels you can jump to with *"goto"{link: goto}* * *:* _(signature symbol)_ {section: colon signature} - prefix of a _"named parameter"{link: named parameter}_ in a signature * *::* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: colon colon sigil} - abstraction "sigil"{link: sigil} and namespace separator in variable/routine/namespace names (like in Perl 5) * *::* _(signature symbol)_ {section: colon colon signature } - introducing a type variable in a signature * *"::="{link: [Perl 6 Variable Tablet] Binding}* {section: colon colon equal op} - "binds"{link: [Perl 6 Variable Tablet] Binding} a value or variable to a variable at compile time * *":="{link: [Perl 6 Variable Tablet] Binding}* {section: colon equal op} - creates an alias to a variable at runtime (_"binding"{link: [Perl 6 Variable Tablet] Binding}_) * *";"{link: [Perl 6 Basics Tablet] Statements}* {section: semicolon} - separates "statements"{link: [Perl 6 Basics Tablet] Statements} (commands) or "array indices"{link: [Perl 6 Variable Tablet] Array Slices}; for example, `@[2;3]` instead of `@a[2][3]` * *<* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: lower op} - "infix"{link: infix category} op, less than, *"True"{link: true}* if numerically ordered the left comes before the right operand * *<>* _(signature symbol)_ {section: lower minus greater signature} double pointy syntax to assign a rw parameter to a block* * *<<* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: lower lower metaop} - applies the operator on the left as hyper operator to the array on the right * *<<==* {section: lower lower equal equal op} - leftward pointing feed operator that adds values to an existing list (append-mode) * *"<< >>"{link: [Perl 6 Basics Tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: double angle brackets} - "circumfix"{link: circumfix category} quoting operator for grouping with autoquoting and evaluation of variables, alias to *Q* *":qq"{link: qq adverb}* *:ww* */.../* * *<=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: lower equal op} - less than or equal, numeric comparison operator see also *<* and *>=* * *<==* {section: lower lequal equal op} - leftward pointing feed operator, take return value of right side and feed as parameter to the left (see also ==> ) * *<=>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: spaceship op} {section: lower equal greater op} - numeric less-equal-greater comparison for sortable classes, does *"cmp"{link: cmp}* in numeric context as *"leg"{link: leg}* does in string context * *"< >"{link: [Perl 6 Basics Tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: angle brackets} - "circumfix"{link: circumfix category} quoting operator for grouping with autoquoting, alias to *"Q"{link: capital Q op}* *:q* *:ww* */.../* or *"qw/.../"{link: qw op}* * *< >* _"(var twigil)"{link: [Perl 6 lookup tablet] Twigils}_ {section: angle brackets twigil} - "circumfix"{link: circumfix category} _"twigil"{link: twigil}_ of named captures, *$<...>* is alias to *"$/<...>"{link: match var}*, was $& and $MATCH in Perl 5 * *< >* _"(regex metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: angle brackets metachar} - embraces an subrule (assertion) * *"="{link: [Perl 6 Variable Tablet] Assignment}* _(Op)_ {section: equal sign} {section: equal op} - "assignment"{link: [Perl 6 Variable Tablet] Assignment}, right side is "evaluated"{link: evaluation} and assigned to the left * {{<op>}} *=* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: equal metaop} - self assignment, left side is one operand and place where the result is assigned to - example: _($a += 3; equals $a = $a + 3)_ * *=:=* _(comparison op)_ {section: equal colon equal op} - compares "binding"{link: [Perl 6 Variable Tablet] Binding}, if both vars are bound to same memory location * *==* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: equal equal op} - *"True"{link: true}* if values are equal in numerical context, as *"eq"{link: eq}* does in string context * *===* _(comparison op)_ {section: triple equal} - identity, equality of value and type * *==>* _(op)_ {section: equal equal greater op} - rightward pointing feed operator, take return value of left side and feed as parameter to the right * *==>>* _(op)_ {section: equal equal greater greater op} - rightward pointing feed operator that adds values to an existing list (append-mode) * *=>* _(op)_ {section: fatarrow} {section: equal greater op} - pair (and hash) constructor, _fatarrow_ * *>* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: greater op} - "infix"{link: infix category} op, numeric greater than * *>=* _"(num comparison)"{link: [perl 6 Operator tablet] Numerical Comparison}_ {section: greater equal op} - "infix"{link: infix category} op, numeric greater than or equal * *>>* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: greater greater op} - binds operator (right) as hyper operator to an array (left) * *"?"{link: [perl 6 Operator tablet] logical selection}* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: question mark op} - forces binary context in an expression, returns *"False"{link: False}* when value is 0 or empty, otherwise *"True"{link: True}*, high precedence version of *"so"{link: so op}* * *?* _(signature symbol)_ {section: question mark signature} - suffix for optional named parameters in signatures * *?* _"(regex metachar)"{link: [perl 6 lookup tablet] Quantifier}_ {section: question mark metachar} - quantifier for 0 or 1 occurrence in Regexes * *?* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: question mark twigil} - _"twigil"{link: twigil}_ (secondary sigil) for constant compiler hint variables * *<?>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: question mark subrule} - matches nothing, returns always *"True"{link: true}*, opposite of *"<!>"{link: exclamation mark subrule}* * *?&* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark ampersand op} - logical _AND_ op, and combinator, forces binary context * *?? !!* (logical op) {section: question mark question mark} {section: ternary op} - ternary or conditional operator; shortcut for *"if"{link: if}* and *"else"{link: else}* * *???* _"(yadda op)"{link: [perl 6 Operator tablet] yadda}_ {section: triple question mark} - yadda operator that calles *"warn"{link: warn}* * *?^* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark caret op} - logical _XOR_, forces operands into boolean context * *?|* _"(bool op)"{link: [perl 6 Operator tablet] bool context}_ {section: question mark pipe op} - logical _OR_, forces operands into boolean context * *@* _"(sigil)"{link: [perl 6 lookup tablet] Sigils}_ {section: at sigil} - "sigil"{link: sigil} of an "array"{link: [perl 6 Variable Tablet] Array} * *@*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: at context op} - forces (flattened) array context, alias to *"list()"{link: list}* function * *<var>[ ]* {section: square brackets slice op} - "postcircumfix"{link: postcircumfix category} operator, appended on an array var, returns an array slice with values which indexes was inside the brackets * *[ ]* {section: square bracket} - "circumfix"{link: circumfix category} operator that creates a reference to an array that holds all values that encompas these brackets * *{{[<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: square bracket metaop} - "circumfix"{link: circumfix category} reduction metaop, applies the operator between all elements of an array, alias to *"reduce"{link: reduce}* * *{{[\<op>]}}* _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: square bracket slash metaop} - "circumfix"{link: circumfix category} reduction metaop, applies above reduction to a series of lists made of array slices ranging in length from 1 to the complete length of the original list, alias to *"triangle"{link: triangle}* * *\* {section: backslash op} - "capture generator"{link: [perl 6 variable tablet] Capture}, creates a _"capture"{link: capture}_ that holds the following structure * *\* {section: backslash} - escape char, all escape sequences inside "quotes"{link: [perl_6_lookup_tablet] Control Chars} and "regexes"{link: [perl_6_lookup_tablet] Escape Sequences} start with it * *^* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: junctive xor} {section: caret op} - junctive _XOR_, requires that one value in a list is *"True"{link: true}*, see also *"one"{link: one}* * *^* {section: caret range op} - upto operator, ^$limit expands to 0 ..^ +$limit range * *^* _"(ranges)"{link: [Perl 6 Operator Tablet] Ranges}_ {section: caret range metachar} - in "range"{link: range op} definitions, it excludes a limit value, in scalar context see smartmatch * *^* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: caret twigil} - for autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables * *^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: caret metachar} - start of the string * *^^* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: double caret op} - logical _XOR_, combines expressions, returns *"True"{link: true}* when only one expression is true, otherwise false, high precedence version of *"xor"{link: xor}* * *^^* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: double caret metachar} - start of a line * *{{$_}}* _"(special var)"{link: [perl 6 lookup tablet] Special Variables}_ {section: underscore} {section: context var} - context var, result of the last command, can set by topicalizers (*"given"{link: given}* and *"for"{link: for}*) * *{}* {section: curly brackets} - "circumfix"{link: circumfix category} operator, encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a *"=>"{link: fatarrow}* * *|* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: pipe op} {section: junctive or} - junctive _OR_, requires that a condition is fulfilled, see also: *"any"{link: any}* * *|* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: pipe metachar} - match alternate patterns with longest token matching (OR - temporal simultaneous connection of patterns) * *|*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: pipe context op} - flatten "capture"{link: [perl 6 variable tablet] Capture} object into arglist, (named parameter) * *||* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: pipe pipe op} {section: high or} - short circuit _OR_, evaluates sequentially, ends evaluation at the first expression that returns *"True"{link: true}*, high precedence version of *"or"{link: or}* * *||* _"(regex Metachar)"{link: [perl 6 lookup tablet] Regex Metacharacter}_ {section: pipe pipe metachar} - match alternate patterns (temporal consequent alternatives) as connected with a logical _OR_ * *||*() _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: pipe pipe context op} - flatten "capture"{link: [perl 6 variable tablet] Capture} object into semicolon list, (positional parameter) * *"~"{link: [perl 6 Operator tablet] String Context}* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_, _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde} {section: tilde op} - forces string context (stringify) and/or concatenate strings, synonym for cat * *~* _"(var twigil)"{link: [perl 6 lookup tablet] Twigils}_ {section: tilde twigil} - _"twigil"{link: twigil}_ for a "grammar"{link: grammar} of a sublanguage * *~&* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde ampersand op} - characterwise _AND_, forces string context * *~<* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde lower op} - characterwise left shift, forces string context * *~>* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde greater op} - characterwise right shift, forces string context * *~^* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde caret op} - characterwise _XOR_, forces string context * *~|* _"(string op)"{link: [perl 6 Operator tablet] string context}_ {section: tilde pipe op} - characterwise or, forces string context * *"~~"{link: [perl 6 Operator tablet] smartmatch}* {section: smartmatch op} {section: tilde tilde op} - smartmatch operator, compares (almost) all variable and data types according a "table"{link: [Perl 6 Lookup Tablet] smartmatch} |
|
* *:a* "(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* _(scalar num op)_ - returns numeric absolute value * *after* - comparison operator used by the Order class, true if left should follow right * *all* - junctive AND operator * *and* - logical AND operator * *andthen* - logical AND short circuit operator, transferring $_ from first to second block/command, if first do succeed * *Any* "(undefined value type)"{link: [perl_6_lookup_tablet] Undefined types} - Perl 6 object (default routine parameter type, excludes junction) * *any* - junctive OR operator * *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* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - demands evaluation of array variables, long form of ":a", included in "", qq and {{<<>>}} * *as* _(scalar method)_ - converts like sprintf * *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 explicitly (";as seen here"{link: [perl_6_lookup_tablet] operator_associativity}) * *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* - inserts on runtime new methods and attributes into a class/grammar or replaces them |
^^ "A"{link: Index} {section: A} |
|
^^ B |
* *:a* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: a adverb} - demands evaluation of array variables that starting with the *"@-sigil"{link: at sigil}*, short form of *":array"{link: array adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *abs* _(numeric op)_ {section: abs} - returns numeric absolute value * *after* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: after} - generic comparison operator used by the Order class, *"True"{link: true}* if left should follow right * *<?after <p>>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: after subrule} - zero-width lookbehind * *all* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: all} - junctive _AND_ operator, *"True"{link: true}* if all conditions (elements of a following list) are fulfilled, see also: *"&"{link: junctive and}* * *<alnum>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: alnum} - a single alphanumeric character, equivalent to *<+alpha +digit>* * *<alpha>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: alpha} - a single alphabetic character * *and* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: and} - short circuit logical _AND_, returns the last defined value (from left to right), low precedence version of *"&&"{link: high and}*, similar to *"andthen"{link: andthen}* * *andthen* _(logical op)_ {section: andthen} - logical _AND_ short circuit operator, transferring *"$_"{link: context var}* from first to second block/expression, if first do succeed, see also: *"orelse"{link: orelse}* * *anon* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: anon} - introduces names that aren't to be stored anywhere (anonymous) * *Any* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Any type} - Perl 6 object (default routine parameter type, excludes junction) * *any* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: any} - junctive _OR_ operator, *"True"{link: true}* when any one condition (of a following list) is true in bool context, see also: *"|"{link: junctive or}* * *{{$*ARGFILES}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: argfiles global var} - magic command-line input handle, was ARGV in P5 * *{{@*ARGS}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: args global var} - arguments (parameter) to a program (script), formerly @ARGV * *arity* _(routine method)_ {section: arity} - returns how many parameters this routine requires, *".count"{link: count}* includes also the optional * *Array* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Array type} - Perl Array, a series of *"Scalar"{link: scalar}* value container, or a variable that stores such a list * *":array"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: array adverb} - demands evaluation of array variables that starting with the *"@-sigil"{link: at sigil}*, long form of *":a"{link: a adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *as* _"(parameter trait)"{link: [Perl 6 lookup tablet]parameter Traits}_ {section: as parameter trait} - data coming through that parameter will be coerced to the type following *as* * *as* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ {section: as routine trait} - inner type constraint that a routine imposes on its return value * *assoc* _"(routine trait)"{link: [Perl 6 lookup tablet]routine traits}_ {section: assoc} - specifies the "associativity of an operator"{link: [Perl 6 Lookup tablet]operator associativity} explicitly * *assuming* {assuming}- method of all subroutine reference objects that enables Currying * _AST_ {section: AST} - (abstract syntax tree), tree like data structure, in which source code is transformed, before running the programm * *async* _(block modifier)_ {section: async} - allows the interpreter to parallelize the following * *augment* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: augment} - adds definitions to an existing name, inserts new methods and attributes into a *"grammar"{link: grammar}* or replaces them, see also: *"supersede"{link: supersede}* |
|
* *:b* "(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* "(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* - comparison operator used by the Order class, true when left should precede right * *BEGIN* "(closure trait)"{link: [perl_6_lookup_tablet] closure_traits} - marks a special block or statement, executed at compile time, ASAP, only ever runs once * _Binding_ - making two variables share the same contents * *Bit* "(immutable type)"{link: [perl_6_lookup_tablet] immutable_types} - Perl single bit (allows traits, aliasing, undef, etc.) * *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* - alters properties of a variable at run time * *bytes* _(scalar 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) |
^^ "B"{link: Index} {section: B} |
|
^^ C |
* *:b* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: b filetest} - file is a block special file (e.g. Harddisks, CDROMs and RAM areas) * *:b* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: b adverb} - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, short form of *":backslash"{link: backslash adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *\B* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital B} - Match when not on a word boundary * *\b* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash b} - zero-width word boundary aka *"<wb>"{link: wb subrule}* * *":backslash"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: backslash adverb} - forces evaluation of "escape sequences"{link: [perl_6_lookup_tablet] escape_sequences}, long form of *":b"{link: b adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * _backtracking_ {section: backtracking} - go after an unsuccessful match back to the last successful matching position and check if another alternative part of the regex matches * *Bag* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bag type} - unordered collection of values that allows duplicates * *base* {section: base} - returns a *"Str"{link: str type}* representing the invocant in base $base (only parameter); Fails if $base is smaller than 2 or larger than 36 * *before* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: before} - generic comparison operator used by the Order class, *"True"{link: true}* when left should precede right * *<?before <p>>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: before subrule} - zero-width lookahead * *BEGIN* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: BEGIN phaser} - marks a special block or statement, executed at compile time, ASAP, only ever runs once * _"binding"{link: [Perl 6 Variable Tablet] Binding}_ {section: binding} - making two variables share the same content by pointing to same memory location * *Bit* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bit type} - Perl single bit (allows traits, aliasing, undef, etc.) * *<blank>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: blank} - a single "blank" character -- in most locales, this corresponds to space and tab * *bless* {section: bless} - calling bless on any invocant (but typically a type object) to create a new object with the same class as the invocant * *Blob* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: blob type} - An undifferentiated mass of bits * *Block* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: block type} - Executable objects that have lexical scopes (enclosed by curly braces) * _block_ {section: block} - syntactically just a piece of code inside curly braces (*{}*), when "evaluated"{link: evaluation} it becomes an object of the type *Block* * *{{&?BLOCK}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: block compiler var} - reference to current block * *Bool* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: bool type} - Perl boolean, can be *"True"{link: True}* or *"False"{link: False}* * *break* _"(flow control)"{link: [perl 6 lookup tablet] Jump Commands}_ {section: break} - leave this when clause block now (see also *"leave"{link: leave}*) * *Buf* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: buf type} - Perl buffer (a stringish array of memory locations), type for raw binary data * *but* {section: but} - adds a *"role"{link: role}* to a *"class"{link: class}* * *bytes* _(string method)_ {section: bytes} - returns number of bytes used (a sort of length) * *:bytes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: bytes modifier} - searching on byte level, (see also chars, codes, graphs) |
|
* *:c* "(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 * *callwith* - submethode by which one can call a sub with a different signature * *capitalize* - alias to ucirst(lc($_)), makes first char of every word upper case, rest lowercase * *Capture* - "(immutable type)"{link: [perl_6_lookup_tablet] immutable_types} - Function call arguments (right-hand side of a binding) * *cat* - concatenes strings, synonym for '~' and array method * *CATCH* "(closure trait)"{link: [perl_6_lookup_tablet] closure_traits} - marks a special block to catch exceptions, before LEAVE * *category* _(grammatical category)_ - namespace of grammatical categories, in case you want to create a new one with a macro * *chars* _(scalar string method)_ - returns number of characters {section: ch} * *: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* _(scalar method)_ - returns a string with the last newline (if there is one) removed * *chop* _(scalar method)_ - returns a string with the last character removed * *chown* - changes owner of files * *circumfix* _(grammatical category)_ - 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)_ - 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* - methode on Filehandle class, ending the connection with a file * *:closure* "(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* _(scalar comp op)_ - compares values textually, gives results -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* _(array method)_ - takes another array as parameter and produces cross product of two arrays (like X operator), eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 * _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* _(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") * *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 |
^^ "C"{link: Index} {section: C} |
|
^^ D |
* *:c* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: c filetest} - file is a character special file (e.g. terminals modems) * *:c* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: c adverb} - forces evaluation of closures (blocks aka {{{...}}}) inside quotes, long form of *":closure"{link: closure adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *:c*(<n>) _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: c modifier} - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue" * *\C[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital C} - any character except the bracketed named or control character * *\c[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash c} - named character or control character * *cached* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: cached} - marks a subroutine as being memoized * *call* {section: call} - execute a subroutine * *caller* {section: caller} - object describing the code from which as routine was invoked * *callframe* {section: callframe} - returns an object that describes a particular call frame as described by a list of matchers * *callwith* {section: callwith} - submethode by which one can call a sub with a different "signature"{link: signature} * *capitalize* {section: capitalize} - alias to a wordwise ucirst( lc( *"$_"{link: context var}* ) ), makes first char of every word upper case, rest lowercase * *"Capture"{link: [perl 6 variable tablet] Capture}* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: capture type} - type holding arguments for a routine call (right-hand side of a binding) * *cat* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: cat} - converts values of a list into string context and joines them like with '~', alias to _.join('')_ * *CATCH* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CATCH phaser} - marks a special block to catch exceptions, before *"LEAVE"{link: LEAVE phaser}* * *categorize* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: categorize} - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, unlike *"classify"{link: classify}* the return value of the mapper can be listref to put the value in several categories or *"Nil"{link: Nil}* to reject the value for categorisation * *category* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: category category} - grammatical category of all grammatical categories (metacategory), useful in case you want to create a new one with a macro * *"ceiling"{link: [perl 6 Operator tablet]}* {section: ceiling} - lowest integer not less than $x (only parameter) * *char* _(num method)_ {section: char} - convert number into charakter according a character table, reverse of _ord_ * *chars* _(string method)_ - returns number of characters {section: ch} of a string, was length in Perl 5 * *:chars* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: chars modifier} - searching on character level (default), (see also bytes, codes, graphs) * *"chdir"{link: [Perl 6 IO tablet] dir}* {section: chdir} - changes the current working directory (*"$*CWD"{link: cwd global var}*) * *CHECK* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CHECK phaser} - marks a special block or statement, executed at compile time, ALAP, only ever runs once * *chmod* {section: chmod} - changes access rights of files * *chomp* _(string method)_ {section: chomp} - returns a string with the last newline (if there is one) removed * *chop* _(string method)_ {section: chop} - returns a string with the last character removed * *chown* {section: chown} - changes owner of files * *"chroot"{link: [Perl 6 IO tablet] chroot}* {section: chroot} - change root directory on POSIX systems * *circumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: circumfix category} - operator namespace of two parted ops that surround the statement, op or variable they affect, most prominent example may be the "double quotes"{link: double quotation marks} * *class* _(block modifier)_ {section: class} - declares a collection of methods that define an object * *{{$?CLASS}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: class compiler var} - current class object * *{{::?CLASS}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: class package compiler var} - name of the current class * *classify* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: classify} - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, classify{{ { chr $_ }, 97..99 returns {"a" => [97], "b" => [98], "c" => [99] } }}, values are always listrefs (see also *"categorize"{link: categorize}*) * *"close"{link: [Perl 6 IO tablet] close}* _(filehandle method)_ {section: close} - releasing the connection to a file via a file handler * *":closure"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: closure adverb} - forces evaluation of closures (blocks aka {{{...}}}) inside quotes, long form of *":c"{link: c adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * _closure_ {section: closure} - routines whose state (content of all local variables) is completely preserved until the next execution * *cmp* _"(generic comparison)"{link: [perl 6 Operator tablet] Generic Comparison}_ {section: cmp} - general "infix"{link: infix category} sort comparator, result is _Order::Increase_ {{(numerically -1)}} if *"before"{link: before}* is *"True"{link: True}* - _Order::Same_ (numerically 0) if *"eqv"{link: eqv}* - _Order::Decrease_ (numerically 1) if *"after"{link: after}*, see also: *"leg"{link: leg}* and *"<=>"{link: spaceship op}*) * *<cntrl>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: cntrl subrule} - a not visible character that is aimed to control the console output * *Code* {section: Code} - data typ for code references of any kind * *:code* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: code adverb} - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi * _coderef_ {section: coderef} - reference (pointer) to an executable block of code (routine) * *:codes* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: codes modifier} - searching on codepoint level (between codepoints), (see also bytes, chars, graphs) * *comb* _(string method)_ {section: comb} - $str.comb(/pattern/) equals {{ $str ~~ m:g/pattern/ }}, except it returns the list of findings, not a match object like *.match(rx/.../)* aka *"m/.../"{link: m op}*, default pattern is rx/./ * *{{@=COMMENT}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: comment pod var} - all the comment blocks in the file * _compile time_ {section: compile time} - the process when Perl converts source code to executable form * *Complex* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: complex type} - Perl complex number * *"conjugate"{link: [perl 6 Operator tablet]}* {section: conjugate} - convert "complex number"{link: complex type} into real (*"Numeric"{link: num type}* type), see also *"abs"{link: abs}* * *constant* _(var trait)_ {section: constant} - makes so declared var (_is constant_) a real constant * *contend* _(block modifier)_ {section: contend} - marks a block as atomic, concurrent proceses have to wait * _context_ {section: context} - when executing a function or operator Perl considers the expression from which the call was to return a scalar or other kind of result * _context variable_ {section: context variable} - name for *"$_"{link: context var}*, which is used by built in Perl functions as an implicit parameter and as memory of the last result * *"continue"{link: [Perl 6 Block tablet] continue}* _(flow control)_ {section: continue} - makes execution in a 'given' also try the following 'when' clauses * *:continue*(<n>) - _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: continue modifier} - searching from nth (n is an int) position (counting from 0) and then going to the right, short for *":c"{link: c modifier}* * *CONTROL* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: CONTROL phaser} - marks a special block to catch control exceptions (like next/last/return etc), before *"LEAVE"{link: LEAVE phaser}* * *Cool* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Cool type} - Perl 6 Convenient OO Loopbacks, * *copy* _"(parameter trait)"{link: [Perl 6 lookup tablet] parameter traits}_ {section: copy} - read-writable copy of the original argument ("pass-by-value") * *cos* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: cos} - cosine, trigonometric function, takes angle in radians; see also *"to-radians"{link: to-radians}*, *"sin"{link: sin}*, *"tan"{link: tan}* * *count* _(routine method)_ {section: count} - returns how many parameters this routine takes (including optional), *".arity"{link: arity}* counts just the required * *cross* _(list method)_ {section: cross} - alias to *"X"{link: capital X}* operator - example: {{ @a X @b = (@a; @b).cross }} * *crosswith* _(list method)_ {section: crosswith} - alias to *"X"{link: capital X metaop}* metaoperator: {{ @a X~ @b = (@a; @b).crosswith(&[~]) = (@a; @b).cross.slice.map { .reduce(&[~]) } }} * _currying_ {section: currying} - creating a subroutine as a derivate from another with certain parameter to be predefined * *{{$*CWD}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: cwd global var} - current working directory (Str) |
|
* *: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* "(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 * _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* - stop the program now and print a message on $*ERR * *dim* - array dimensioning * *div* - division, creates fraction objects in Integer context * *do* - executes a block (do once loop) * *does* - checks if an objekt inherits this role * *:double* "(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 |
^^ "D"{link: Index} {section: D} |
|
^^ E |
* *:d* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: d filetest} - check if file is a directory * *\D* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital D} - a single nondigit character * *\d* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash d} - a single digit character * *{{$=data}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: data scalar pod var} - handle for the data block (=begin data ... =end data) * *{{@=data}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: data array pod var} - lines of the data block (=begin data ... =end data) * *"decode"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: decode} - transforms raw binary UTF (Buf) 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_ {section: Declarative Programming} - programming paradigm that expresses the logic of a computation without describing its control flow * *defer* _(block modifier)_ {section: defer} - * *defined* {section: defined} - scalar method tests whether a value has been assigned to a variable * *delete* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: delete} {section: array delete} - removes all values of which indices are passed * *delete* _(hash method){link: [Perl 6 Variable Tablet]Hash Methods}_ {section: hash delete} - removes all "pairs"{link: pair} of which keys are passed * *denominator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: denominator} - returns the denominator of a rational number (value type Rat and FatRat) * _Design by Contract_ {section: Design by Contract} - programming style in which parameters and return values from routines must meet conditions; A signature is considered contract in Perl 6 * *die* {section: die} - throws a fatal Exception, the default exception handler *"print"{link: print}*'s each element of the list to *"$*ERR"{link: err global var}* * *<digit>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: digit subrule} - single (decimal) digit char aka *"\d"{link: backslash d}* * *"dir"{link: [Perl 6 IO tablet] dir}* {section: dir} - returns all files of a given directory, excluding . and .. by default * *{{$*DISTRO}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: distro global var} - name of running "OS"{link: osname global var} distribution * *{{$?DISTRO}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: distro compiler var} - name of "OS"{link: osname global var} distribution compiled for * *"div"[Perl 6 Operator Tablet]* {section: div} - integer division * *"do"{link: [Perl 6 Block tablet] do}* {section: do} - executes a block (do once loop) * *does* {section: delete}- checks if an objekt inherits a role (parameter) * *dotty* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: dotty category} - * *":double"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: double adverb} - _double quoting_, *q* with interpolation of variables, alias to *""...""{link: double quotation marks}*, *"qq /.../"{link: qq op}* and *Q :s :a :h :f :c :b /.../*, long for *":qq"{link: qq adverb}* * *Duration* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: duration type} - The difference between two Instants * *dynamic* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: dynamic} - parameter is an "environmental" variable, a lexical in the dynamic scope |
|
* *:e* "(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)_ - returns number of elements * *else* "(block modifier)"{link: [perl_6_lookup_tablet] Conditionals} - introduces the alternative block after an 'if' or 'elsif' * *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* - equal, string comparison * *equiv* "(routine trait)"{link: [perl_6_lookup_tablet] routine_traits} - specifies the precedence of an operator same as an existing operator ("as seen here"{link: [perl_6_lookup_tablet] table_of_precedence}) * *eqv* - compares the dynamic state of objects and values, in contrast with static === * *err* _(logical operator)_ - returns the first defined value from the left * *: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 executed and 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 |
^^ "E"{link: Index} {section: E} |
|
^^ F |
* *:e* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: e filetest} - tests if file exists * *\E* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital E} - anything but an escape character * *\e* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash e} - escape character * *each* {section: each} - variant of all() that promises to do things in order, is Positional/Iterable * *eager* {section: eager} - forces eager evaluation (compute all values now), default for scalars - not for lists * *{{$*EGID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: egid global var} - effective global ID of the running process (*"$*PID"{link: pid global var}*) owner, was @) and $EGID in Perl 5 * *elems* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: elems} {section: array elems} - number of elements (values), *"end"{link: end}* * *elems* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: elems hash} - number of pairs * *"else"{link: [Perl 6 Block tablet] else}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: else} - introduces the alternative block after an *"if"{link: if}* or *"elsif"{link: elsif}*, that is executed, when conditions of all alternatives resulted in *false* (see also *default*) * *"elsif"{link: [Perl 6 Block tablet] elsif}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: elsif} - alternative if clause * *"encode"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: encode} - transforms readable UTF Text (Str) into raw binary UTF (Buf) * *END* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: END phaser} - marks a special block, executed at run time, ALAP, only ever runs once * *end* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: end} - last index of that list, see also: *"elems"{link: elems}* * *ENTER* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: ENTER phaser} - marks a special block or statement, executed at every block entry time, repeats on loop blocks * *Enum* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Enum type} - An immutable Pair * *enum* {section: enum} - enum takes a list of keys or pairs and adds values to any keys that are not already part of a pair (one more than the previous key had) - example: _{{%hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;}}_ * *EnumMap* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Enummap type} - A mapping of Enums with no duplicate keys * *{{%*ENV}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: env global var} - environment variables (of the shell), was %ENV in P5 * *eq* _"(comparison op)"{link: [perl 6 Operator tablet] String Comparison}_ {section: eq} - "infix"{link: infix category} operator, proves equality in forced string context * *equiv* _"(routine trait)"{link: [Perl 6 Lookup Tablet]Routine Traits}_ {section: equiv} - specifies the "precedence of an operator"{link: [Perl 6 lookup tablet]Table of Precedence} same as an existing operator * *eqv* _(comparison op)_ {section: eqv} - "infix"{link: infix category} operator, compares the dynamic state of objects and values, in contrast with static *"="{link: triple equal}* * *err* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: err} - short circuit defined or, returns the first defined value from the left, short circuit or,low precedence version of *"//"{link: high err}* * *{{$*ERR}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: err global var} - standard error output (command line mostly), STDERR in Perl 5 * *{{$*EUID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: euid global var} - effective user ID of the running process (*"$*PID"{link: pid global var}*) owner, was @> and $EUID in Perl 5 * *eval* {section: eval} - just evaluates a string as a program and returns result and maybe error message in *"$!"{link: exclamation mark var}*, second optional parameter defines a parser grammar which should understand the string * _evaluation_ {section: evaluation} - reading the human written source code and make it an executable (piece of) program * *evalfile* {section: evalfile} - evals a file like "do" did in Perl 5, with optional second parameter, which is a grammar that can parse that file * *:ex* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ex modifier} - searching at all positions as long as it findes something (with backtracking), short for *":exhaustive"{link: exhaustive modifier}* * *Exception* _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: exception type} - Perl exception, errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle * *:exec* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: exec adverb} - quoted string will be evaluated as Perl code (like *"eval"{link: eval}*) replaced with its result, alias to *Q :x* and *"qx/.../"{link: qx op}* * *{{$*EXECUTABLE_NAME}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: executable name global var} - name of the main scripts file name, was _$0_ in Perl 5 * *:exhaustive* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: exhaustive modifier} - searching at all positions as long as it findes something (with backtracking), long for *":ex"{link: ex modifier}* * *exists* {section: exists} - checks for existence of a variable, array or hash member, scalar method * *exit* _(flow control)_ {section: exit} - stops all program execution, and returns Int $status (first parameter) to the calling environment * *exp* {section: exp} - exponentiate, alias method to: $base (first parameter) *{{**}}* $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* "(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* - a return call (end this routine) that throws an 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* - flip flop operator in the style of awk, formerly .. in scalar context * *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 * *flip* _(scalar string op)_ - reverses order of characters in strings * *fmt* - method on a scalar, takes a format specifier returns a string, simplified sprintf * *for* "(loop block modifier)"{link: [perl_6_lookup_tablet] Loops} - only iterates over a list * *:function* "(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, considered as a branch of Declarative Programming |
^^ "F"{link: Index} {section: F} |
|
^^ G |
* *:f* _"(filetest op)"{link: [Perl 6 Lookup Tablet]Filetest Ops}_ {section: f filetest} - file is a plain file (no socket or dir, ...etc.) * *:f* _"(quoting adverb)"{link: [Perl 6 Lookup Tablet]Quoting Adverbs}_ {section: f adverb} - demands evaluation of functions (subs and methods), that start with the *"&-sigil"{link: ampersand sigil}* and replacing them with the result, long form of *":function"{link: function adverb}* , included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *\F* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital F} - anything but form feed * *\f* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash f} - form feed * *fail* {section: fail} - causes the routine to return an unthrown exception, if _use fatal_ is in effect where the routine was called from, it throws the exception * *Failure* _"(undefined value type)"{link: [Perl 6 lookup tablet] Undefined types}_ {section: Failure type} - data type object for an error, thrown by an unhandled exception * *False* {section: false} - boolean value aka Bool::False, 0 in numeric context, {{''}} (empty) in string context * *FatRat* _"(immutable type)"{link: [Perl 6 lookup tablet] immutable types}_ {section: fatrat type} - Perl rational (unlimited precision in both parts) * *"ff"{link: [Perl 6 Operator tablet]flipflop}* {section: ff} - flip flop operator in the style of awk, formerly .. in scalar context * *"fff"{link: [Perl 6 Operator tablet]flipflop}* {section: fff} - flip flop operator in the style of sed, formerly ... in scalar context * *{{$?FILE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: file compiler var} - current filename of source file * *FIRST* _"(closure trait)"{link: [Perl 6 lookup tablet]closure traits}_ {section: FIRST phaser} - marks a special block or statement, executed at loop initialization time, before any *"ENTER"{link: ENTER phaser}* * *first* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: first} - returns first value of a list that passes a condition (first paramter); the condition is a closure that takes one value at a time (as *"$_"{link: context var}* or $^a); works like *"grep"{link: grep}* - example : _{{first {$_ %% 2}, 1..5}}; # returns 2_ * *flat* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: flat} - forces flat list context, opposite of *"lol"{link: lol}* - example: _{{([2,3],[4,5]).flat or flat([2,3],[4,5]) results in: [2..5]}}_ * *flip* _(string method)_ {section: flip} - reverses order of characters in strings, see also: *"reverse"{link: reverse}* and *"invert"{link: invert}* * *"fmt"{link: [Perl 6 Basics tablet] fmt}* _(formater)_ {section: fmt} - variable method for simple *"printf"{link: printf}* - like formating, takes a format specifier and returns a string; format specifier accepts only 1 value placeholder, in case of a hash max. 2; second, optional parameter is delimiter between values or pairs (in case of a hash); * *"for"{link: [Perl 6 Block tablet] for}* _"(loop block modifier)"{link: [Perl 6 lookup tablet]Loops}_ {section: for} - only iterates over a list and sets *"$_"{link: context var}* for each iteration * *"fork"{link: [Perl 6 IO Tablet] Processes}* {section: fork} - creates a copy of the current process and returns in the original process a Proc object of the child (0 in num context) and in the child a proc object of the original (process ID in num context) * *from-radians* {section: from-radians} - convert from radians to $base (second parameter), opposite of *"to-radians"{link: to-radians}* * *":function"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: function adverb} - demands evaluation of functions (subs and methods), that start with the *"&-sigil"{link: ampersand sigil}* and replacing them with the result, long form of *":f"{link: f adverb}* , included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * _Functional Programming_ {section: Functional Programming} - exclusively function based programming style, "strongly supported"{link: [Perl 6 Delta Tablet] Functional Programming} by Perl 6, considered as a branch of Declarative Programming |
|
* *:g* "(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* _(block modifier)_ - performs the following block once, returns a list of all values passed by 'take' * *ge* - greater than on equal, string comparison * *get* _(handle method)_ - returns a line (scalar context) or all lines (array context) from that input stream * *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* "(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) * *group* - * *gt* - greater than or equal, string comparison |
^^ "G"{link: Index} {section: G} |
|
^^ H |
* *:g* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: g filetest} - report if file has setgid bit set * *:g* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: g modifier} - searching for any finding (not just the first), short for *":global"{link: global modifier}* * *gcd* _"(numeric infix op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: gcd} - greatest common divisor (see also: *"lcm"{link: lcm}*) * *"gather"{link: [Perl 6 Block Tablet ]gather and take}* _(block modifier)_ {section: gather} - performs the following block once, returns a list of all values passed by *"take"{link: take}* * *ge* _"(infix string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: ge}- greater than or equal, see also *"gt"{link: gt}* and *"le"{link: le}* * *"get"{link: [Perl 6 IO tablet] get}* _(handle method)_ {section: get} - returns a line (item context) or all lines (list context) from that input stream like a file or "command line"{link: [Perl 6 IO tablet] Command Line} * *"getc"{link: [Perl 6 IO tablet] getc}* _(handle method)_ {section: getc} - reads one character from a file via file handle * *getlogin* {section: getlogin} - returns the username of the account running the program, maybe less secure as *"getpwuid"{link: getpwuid}* * *gethost* {section: gethost} - establish a connection to a net host and retrieve information * *{{$*GID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: gid global var} - real global ID of the running process (*"$*PID"{link: pid global var}*) owner, was @( and $GID in Perl 5 * *"given"{link: [Perl 6 Block tablet] given}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ {section: given} - case construct puts a value into the "context variable"{link: context var} for *"when"{link: when}* clauses * *:global* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: global modifier} - searching for any finding (not just the first), long for *":g"{link: g modifier}* * *"goto"{link: [Perl 6 Block tablet] goto}* _"(flow control)"{link: [Perl 6 lookup tablet]jump commands}_ {section: goto} - continue execution on a defined label (with "name:") * *grab* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: grab} - random selection of hash keys, weighted by its related values, grabbing a key decrements its value (local copy) by one (deleting key when it goes to 0), see also *"pick"{link: pick}* ans *"roll"{link: roll}* * *grabpair* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: grabpair} - random selection <n> (only parameter) of hash *"pairs"{link: pair}*, (each pair only once) , see also *"pick"{link: pick}* ans *"roll"{link: roll}* * *grammar* {section: grammar} - special kind of *"class"{link: class}* with methods that execute *"regex"{link: regex}*, *"token"{link: token}* and *"rule"{link: rule}* * *{{$?GRAMMAR}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: grammar compiler var} - grammar of the currently used language (mostly *"$~MAIN"{link: main var}*) * *<graph>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: graph subrule} - a "graphical" character * *:graphs* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: graphs modifier} - searching on the level of language-independent graphemes, (see also bytes, chars, codes) * *grep* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: grep} - returns all values of an array that pass a filter condition (first parameter); the condition is a closure that takes one value at a time (as *"$_"{link: context var}* or $^a); see also *"first"{link: first}* - example : _{{grep {$_ %% 2}, 1..5}}; # returns 2 4_ * *gt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: gt} - "infix"{link: infix category} operator, greater than or equal, *"True"{link: true}* if alphabetically ordered the right comes before the left (see also *"lt"{link: lt}*, *"leg"{link: leg}* and *<*) |
|
* *:h* "(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* - creates an attribute for an object * *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* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - demands evaluation of hash variables, long form of ":h", included in "", qq and {{<<>>}} * *:heredoc* "(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) |
^^ "H"{link: Index} {section: H} |
|
^^ I |
* *:h* _"(quoting adverb)"{link: [Perl 6 lookup Tablet]Quoting Adverbs}_ {section: h adverb} - demands evaluation of *"hash"{link: Hash}* variables that start with the *"%-sigil"{link: percent sigil}*, long form of *":hash"{link: hash adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *\H* _"(escape sequence)"{link: [Perl 6 lookup Tablet]Escape Sequences}_ {section: backslash capital H} - anything but horizontal whitespace char * *\h* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash h} - horizontal whitespace char, part of *"\s"{link: backslash s}* * *handles* {section: handles} - delegates execution of a function to another method * *HardRoutine* - _"(immutable type)"{link: [Perl 6 lookup tablet]Immutable Types}_ {section: hardroutine type} - A routine that is committed to not changing * *has* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: has} - introduces attribute names, see also *"class"{link: class}* * *Hash* _"(mutable type)"{link: [Perl 6 lookup tablet]Mutable types}_ {section: hash type} - Perl hash, a two column table of _Scalar_, values in one column are keys to refer to the values in the other column * *hash* _"(context op)"{link: [Perl 6 lookup tablet]Contextualizers}_ {section: hash} - enforces hash-list context, alias to *"%()"{link: percent op}* * *":hash"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: hash adverb} - demands evaluation of hash variables that start with the *"%-sigil"{link: percent sigil}*, long form of *":h"{link: h adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *":heredoc"{link: [Perl 6 basics tablet]Heredocs}* _"(quoting adverb)"{link: [Perl 6 lookup tablet]Quoting Adverbs}_ {section: heredoc adverb} - defines end marker for the following heredoc, *:heredoc* is equal to *":to"{link: to adverb}* * *HOW* _"(introspection method)"{link: [Perl 6 lookup tablet]object introspection}_ {section: how introspection } - (reserved for documentation) * *hyper* {section: hyper} - forces none-lazy list context, that ignores the order of results (allowes parallel computing) |
|
* *:i* "(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* "(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) * *: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* - finds the first occurrence of a substring from a position in a string * *Inf* - infinity, to generate infinite lazy lists * *infix* _(grammatical category)_ - 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 pairs and hashes * *IO* "(mutable type)"{link: [perl_6_lookup_tablet] mutable_types} - Perl filehandle * *is* - bind a traits to a variable * _Iteration_ - flow control, repeatedly executing a block * *Iterator* "(mutable type)"{link: [perl_6_lookup_tablet] mutable_types} - Perl list |
^^ "I"{link: Index} {section: I} |
|
^^ J |
* *:i* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: i modifier} - uppercase and lowercase variants of a letter are taken as the same letter, short for *":ignorecase"{link: ignorecase modifier}* (same as in Perl 5) * *"if"{link: [Perl 6 Block tablet] if}* _"(block modifier)"{link: [Perl 6 lookup tablet]Conditionals}_ {section: if} - flow control conditional statement or block modifier, executes following code block only when a condition expression evaluates to *"True"{link: true}* (see also *"elsif"{link: elsif}* and *"else"{link: else}*) * *:ignorecase* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ignorecase modifier} - uppercase and lowercase variants of a letter are taken as the same letter, long for *":i"{link: i modifier}* (same as in Perl 5) * *:ignoremark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ignoremark modifier} - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, long for *":m"{link: m modifier}* * *:ii* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: ii modifier}- only for substitutions, replacing with chars that have the same case pattern as the replaced, short for *":samecase"{link: samecase modifier}* * *"import"{link: [Perl 6 Subroutine tablet] }* {section: import} - just import definitions from an already loaded module (see *"use"{link: use}* and *"need"{link: need}*) * *{{$*IN}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: in global var} - standard input (command line mostly), see also *"$*OUT"{link: out global var}* * *{{@*INC}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: inc global var} - include pathes (but not for standard library modules), formerly @INC * *index* _(string method)_ {section: index} - finds the first occurrence of a substring in a string and returns the numerical position, opposite or _rindex_ * *Inf* {section: Inf} - infinity, to generate infinite lazy lists, does same as *"*"{link: asterisk op}* * *infix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix category} - namespace of symbols that stay between two statements, that become their parameters - example: _{{$a + $b # is same as $a.&infix:<+>($b)}}_ * *infix_circumfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_circumfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "circumfix"{link: circumfix category} other operator but stay "infix"{link: infix category} (between) two terms (mostly lists) - example (the arrows): _ @a <<+<< @b_ * *infix_postfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_postfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "postfix"{link: postfix category} other operator but stay "infix"{link: infix category} (between) two terms - example (equal sign): _ $a += 5_ * *infix_prefix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: infix_circumfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "prefix"{link: prefix category} (precedes) other operator but stay "infix"{link: infix category} (between) two terms - example (exclamation mark): _ 4 != 5_ * *INIT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: INIT phaser} - marks a special block or statement, executed at run time, ASAP, only ever runs once * *inline* _(sub trait)_ {section: inline} - * *Instant* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: instant type} - a point on the continuous atomic timeline * *Int* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: int type} - Perl integer (allows Inf/NaN, arbitrary precision, etc.); use it as method to convert into a int like the Perl 5 "int" * *invert* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: invert} - inverts the key => value relation of a pair or a series of pairs (hash), returning a *"Pair"{link: Pair}* *"list"{link: list}*, see also *"reverse"{link: reverse}* and *"flip"{link: flip}* * *IO* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: io type} - Perl filehandle * *is* {section: is} - bind a traits to a variable * *item()* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: item} - forces scalar context, alias to *"$()"{link: dollar op}* * _Iteration_ {section: iteration} - flow control, repeatedly executing a block * *Iterator* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: iterator type} - Perl list |
|
* *join* _(array method & op)_ - concatenates list elements into a string, optionally inserting another string between the elements |
^^ "J"{link: Index} {section: J} |
|
^^ K |
* *join* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: join} - concatenates list elements into a string, optionally inserting another string between the elements - example: _{{join("-", 1..5) # returns '1-2-3-4-5' - or (1..5).join("-")}}_ |
|
* *:k* "(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)_ - 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)_ - returns list of hash keys * *kv* _(hash method)_ - returns list of key-value pairs |
^^ "K"{link: Index} {section: K} |
|
^^ L |
* *:k* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: k filetest} - report if file has sticky bit set * *KEEP* _"(closure trait)"{link: [Perl 6 lookup tablet]Closure traits}_ {section: KEEP phaser} - marks a special block, executed at every successful block exit, part of *"LEAVE"{link: LEAVE phaser}* queue * *:keepall* _"(regex modifier)"{link: [Perl 6 Lookup tablet]Regex Modifier}_ {section: keepall modifier} - forces subrules to memorize everything (even comments) * *key* _"(pair method)"{link: [Perl 6 Variable Tablet]Pair}_ {section: key} - gives the key part of a pair, opposite of *"value"{link: value}* * *KeyBag* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ {section: KeyBag type} - KeyHash of UInt (does Bag in list/array context) * *KeySet* _"(mutable type)"{link: [Perl 6 lookup tablet] mutable types}_ {section: KeySet type} - KeyHash of *"Bool"{link: Bool type}* (does Set in list/array context) * *keys* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: array keys} - returns the list array indexes * *keys* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: keys} - returns list of hash keys * *"kill"{link: [Perl 6 IO Tablet] Processes}* {section: kill} - sends the given $signal to the process(es) given and returns a boolean value indicating success (*"True"{link: true}*) * *kv* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: kv} - returns list of key-value pairs |
|
* *:l* "(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)_ - number of final element * *lazy* - forces lazy evaluation (as late as possible) * *lc* _(scalar string op & method)_ - make string lowercase * *lcfirst* _(scalar string op & method)_ - make first char of a string lowercase * *le* _(comparison op)_ - lower than or equal, string comparison * *LEAVE* "(closure trait)"{link: [perl_6_lookup_tablet] closure_traits} - marks a special block, executed at every block exit time * *leave* "(flow control)"{link: [perl_6_lookup_tablet] jump_commands} - exit the current block with a return value * *leg* _(comparison op)_ - lower/equal/greater comparator for text * *let* - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully * *lines* _(handle method)_ - returns an lazy iterator over all chomped lines of that input stream * *lines* _(io op)_ - reads a file and returns content as array of lines, works as above * *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 lower than an existing operator ("as seen here"{link: [perl_6_lookup_tablet] table_of_precedence}) * *lt* _(string comparison op)_ - lower than, string comparison |
^^ "L"{link: Index} {section: L} |
|
^^ M |
* *:l* _"(filetest op)"{link: [Perl 6 lookup tablet]Filetest Ops}_ {section: l filetest} - file is a symbolic link * *\L[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet]Escape Sequences}_ {section: backslash capital L} - everything within the brackets is lowercase * *{{$*LANG}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: lang global var} - LANG variable from *"%*ENV"{link: env global var}* that defines what human language is used * *LAST* _"(closure trait)"{link: [Perl 6 lookup tablet] closure traits}_ {section: LAST phaser} - marks a special block, executed at loop termination time, after any *"LEAVE"{link: LEAVE phaser}* * *last* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: last} - exit the current looping block * *last* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: last} - number of final element * *lazy* - forces lazy evaluation (calculate values as late as possible), default for lists {section: lazy} - not scalars * *lc* _(string op & method)_ {section: lc} {section: lc} - make string lowercase * *lcfirst* _(string op & method)_ {section: lcfirst} - make first char of a string lowercase * *lcm* _"(numeric infix op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: lcm} - least common multiple, see also: *"gcd"{link: gcd}* * *le* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: le} - "infix"{link: infix category} operator, result is *"True"{link: true}* if left side is lower than or equal than the right, see also: *"lt"{link: lt}*, *"gt"{link: gt}* and *"ge"{link: ge}* * *LEAVE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: LEAVE phaser} - marks a special block, executed at every block exit time * *"leave"{link: [Perl 6 Block tablet] leave}* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: leave} - exit the current block with a return value * *leg* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: leg} - general "infix"{link: infix category} sort comparison operator in "string context"{link: string context}, leg stands for lower/equal/greater, *"cmp"{link: cmp}* is the more general form, *"<=>"{link: spaceship op}* does same in "numerical context"{link: numerical context}, was cmp in P5 * *let* {section: let} - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully * *{{$?LINE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: line compiler var} - current line number * *"lines"{link: [Perl 6 Basics tablet] }* _(string & iomethod)_ {section: lines} - returns a chomped list of lines (chunks of character separated by *"\n"{link: backslash n}*) containing a string - example: {{ $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit ) }}, works also on file handles * *list()* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: list} - almost a no-op, just makes sure that $item (first parameter) can be iterated, alias to *"@()"{link: at op}*, see also *"flat"{link: flat}* and *"lol"{link: lol}* * _list context_ - * *"log"{link: [perl 6 Operator tablet]}* {section: log} - logarithm of $x (first parameter) to the $base (second optional parameter - default is _e_, together also known as _ln_ ) * *"log10"{link: [perl 6 Operator tablet]}* {section: log10} - logarithm to the base of 10, also known as lg on calculators * *lol* _"(context op)"{link: [perl 6 lookup tablet] Contextualizers}_ {section: lol} - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of *"flat"{link: flat}* * _longest token matching_ {section: longest token matching} - (short _LTM_) when searching a pattern with alternatives (sub|substr) the search will continue after finding the pattern 'sub' because of looking for the longest alternative * *"loop"{link: [Perl 6 Block tablet] loop}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: loop} - general flow control command for repetition * *looser* _"(routine trait)"{link: [Perl 6 lookup tablet]Routine Traits}_ {section: looser} - specifies the "precedence of an operator"{link: [perl 6 lookup tablet] table of precedence} lower than an existing operator * *<lower>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: lower subrule} - a single lowercase character * *lt* _"(string comparison)"{link: [perl 6 Operator tablet] String Comparison}_ {section: lt} - "infix"{link: infix category} operator, lower than, *"True"{link: true}* if alphabetically ordered the left comes before the right |
|
* *m* "(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)_ * *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* - 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* - compare a string to a regex/token/rule, alias to smartmatch operator (~~) * _match object_ - result of an regex operation * *max* _(list op)_ - 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* - returns the numerically smallest value from a given list * *minmax* - returns the highest and lowest values from a list, as a 2 item list * *mod* _(scalar op)_ - generic modulo operator * *module* _(block modifier)_ - introduces a module name, a package that performs special actions on loading * *ms* "(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* _(var scope)_ - makes a variable or routine lexical, therefore exists and is valid only in the current scope (usually a block) |
^^ "M"{link: Index} {section: M} |
|
^^ N |
* *"m//"{link: [Perl 6 Regex Tablet] Matching}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: m op} - perform a regex based search in place (m stands for _match_ ), similar to *"match"{link: match}*-method * *:m* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: m modifier} - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for *":ignoremark"{link: ignoremark modifier}* * *Macro* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: macro type} - Perl compile-time subroutine * *macro* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: macro} - define a routine to alter source code at compile time * *{{$~MAIN}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: main var} - current "grammar"{link: grammar} of main language, tells the parser the rules of parsing Perl * *map* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: map} - take a list, perform a block on each member, return a list of the results - example: _{{say map { chr $_ }, 66..69}}_ (is "B C D E") or _{{say map { chr $_ }, 66..69}}_ * *Match* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: macth type} - Perl match object, usually produced by applying a pattern of _"regular expression"{link: regular expression}_ to a string * *match* _(string method)_ {section: match} - method alias to *"m/.../"{link: m op}*, $str.match( /<p>/ ) equals $str ~~ m/<p>/;, returns a match object that end up also in *"$/"{link: match var}* * *max* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: max} - returns the numerically largest value from a given list * *maybe* _(block modifier)_ {section: maybe} - * _"metaoperator"{link: [perl 6 lookup tablet] metaoperators}_ {section: metaoperator} - alters the meaning of other operators * *Method* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: method type} - Perl method * *method* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: method} - defines a method (inheritable routine) in a class * *min* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: min} - returns the numerically smallest value from a given list * *minmax* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: minmax} - returns the highest and lowest values from a list, as a 2 item list * *:mm* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: mm modifier} - substitute with chars that has same mark/accent pattern as the matched string, short for *":samemark"{link: samemark modifier}* * *"mkdir"{link: [Perl 6 IO tablet] mkdir}* {section: mkdir} - creates a directory with given name * *mod* _(numeric op)_ {section: mod} - integer modulo operator; wordy alias to *"%"{link: percent}* - example: _5 mod 4 = 1;_ * *module* _(block modifier)_ {section: module} - introduces a module name, a package that performs special actions on loading * *{{&?MODULE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: module compiler var} - reference to the current module * *"ms//"{link: [Perl 6 Regex Tablet] Matching}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: ms op} - perform a regex based search in place, spaces are just subrule separators, alias to *m:s/.../* or *m* *":sigspace"{link: sigspace modifier}* */.../* * *Mu* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Mu type} - most (generic) undefined object * *multi* _"(routine modifier)"{link: [perl 6 lookup tablet] Routine Modifier}_ {section: multi} - marks routines with can have sibling with same name but different _"signature"{link: signature}_, when called, the one with matching sig is executed (multimethod dispatch) * *my* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: my} - introduces lexically scoped names, which exists only in the current scope (usually a block) |
|
* *\N* "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) * *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 * *none* - return true when a value is not part of a set, junctive NOT operator * *not* - logical NOT operator, negates truth value, alternative to `!` with lower precedence * *Num* "(immutable type)"{link: [perl_6_lookup_tablet] immutable_types} - Perl number (approximate Real, generally via floating point) |
^^ "N"{link: Index} {section: N} |
|
^^ O |
* *\N* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital N} - anything but (logical) newline * *\n* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash n} - (logical) newline * <n> *:nd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: nd modifier} - demands the nth finding (:2nd), has many aliases (*:st* *:rd* *:th*) for correct spelling * *name* _(routine method)_ {section: name} - returns the name of of a routine, handy when it was stored in a scalar * *"need"{link: [Perl 6 Subroutine tablet] }* {section: need} - just load a module, without import definitions (see *"use"{link: use}* and *"import"{link: import}*) * *new* {section: new} - creates a new object of a class(as in most other languages), also name of the automatically called constructor method * *NEXT* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: NEXT phaser} - marks a special block, executed at loop continuation time, before any *"leave"{link: LEAVE phaser}* * *next* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: next} - start the the next following loop iteration * *nextsame* {section: nextsame} - get from the dispatcher the next candidate with the same _"signature"{link: signature}_, similar to javas SUPER * *Nil* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: nil type} - unlike _undef_ in Perl 5 it really means no value here - example: _@a = Nil, Nil; # array has zero elements_ * *none* _(junctive op)_ {section: none} - return *"True"{link: true}* when a value is not part of a set, junctive _NOT_ operator * *normalize* - _(string method)_ {section: normalize} - normalize (repair) Unicode (UTF) string * *not* _"(logical op)"{link: [perl 6 Operator tablet] bool context}_ {section: not} - logical _NOT_ operator, returns *"False"{link: false}* if value is positive or *"True"{link: true}* if negates, low precedence version of *!* * *"note"{link: [Perl 6 IO tablet] note}* {section: note} - makes output via command line ($ERR) like *"warn"{link: warn}*, but appends a newline (*"\n"{link: backslash n}*) like *"say"{link: say}* * *Num* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Num type} - Perl number (approximate Real, generally via floating point) * *numerator* _"(rat method)"{link: [Perl 6 Basics Tablet] Rational Number}_ {section: numerator} - returns the numerator of a rational number (value type Rat and FatRat) |
|
* *:O* "(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 * *or* - logical or operator * *orelse* - logical OR short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to *//* * *our* _(var scope)_ - makes a variable or subroutine name visible in all the current package * *: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" |
^^ "O"{link: Index} {section: O} |
|
^^ P |
* *:O* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital O filetest} - tests if file is owned by real uid * *:o* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: o filetest} - tests if file is owned by effective uid * _Object Oriented Programming_ {section: object oriented programming} - programming paradigm (style), that arranges data and functions that belong together into so called objects * *of* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: of} - inner type constraint that a routine imposes on its return value - example: _subset Month of Int where { 1 <= $^a <= 12 }_ * *one* _"(junctive op)"{link: [perl 6 Operator tablet] junctions}_ {section: one} - junctive _XOR_ operator, *"True"{link: true}* if only one expression (of a following list) is true in bool context, see also: *"|"{link: junctive xor}* * *only* _"routine modifier"{link: [perl 6 lookup tablet] routine modifier}_ {section: only} - permits only one routine of the same name in this block * *"open"{link: [Perl 6 IO tablet] open}* _(path method)_ {section: open} - establishes a connection to a file via a file path name file handler * *or* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: or} - short circuit _OR_, "evaluates"{link: evaluation} sequentially, ends evaluation at the first expression that returns *"True"{link: true}*, low precedence version of *"||"{link: high or}*, similar to *"orelse"{link: orelse}* * *ord* _(string method)_ {section: ord} - convert charakter into number according a character table, reverse of _char_ * *orelse* _(logical op)_ {section: orelse} - logical _OR_ short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to *"//"{link: high err}*, see also *"andthen"{link: andthen}* * *{{$*OSNAME}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: osname global var} - name of running operating system * *our* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: our} - introduces *"package"{link: package}* - scoped names for variables and routines * *{{$*OUT}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: out global var} - standard output (command line mostly), see also *"$*IN"{link: in global var}* * *:ov* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ov modifier} - searching at all positions just one time (with backtracking), short for *:overlap* * *:overlap* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: overlap modifier} - searching at all positions just one time (with backtracking), long for *:ov* |
|
* *:p* "(filetest op)"{link: [perl_6_lookup_tablet] Filetest Ops} - file is a named pipe (FIFO), or filehandle is a pipe * *: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 * *p5=>* _(array op)_ - hash constructor, that works like in Perl 5, generates just a list that can converted in hash context to an hash * *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)_ - 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 * *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 method)_ - select a number of random vaues * "phaser"{link: [perl_6_lookup_tablet] closure traits} - Perl 6 term for specially named subblocks withe special runtimes aka closure traits * *pick* _(array method)_ - 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)_ - 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)_ - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2]) * *postfix* _(grammatical category)_ - 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 * *prefix* _(grammatical category)_ - operator namespace of ops, that stay before a statement or variable (like ++$a) * *print* - sends characters to an output stream without adding a newline, see 'say' * *printf* - formats text and sends it to standard output * *prompt* - "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)_ - adds a list of values to the end of an array |
^^ "P"{link: Index} {section: P} |
|
^^ Q |
* *:p* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: p filetest} - file is a named pipe (FIFO), or filehandle is a pipe * *":p"{link: [Perl 6 Basics tablet] Paths}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: p adverb} - quote paths and create path object that know the right format of the current *"$*OSNAME"{link: osname global var}* with *{{Q :p /.../}}*, short for *":path"{link: path adverb}* * *:p*(<n>) _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: p modifier} - searching only on the nth (n is an int) position (counting from 0), short for *":pos"{link: pos modifier}* * *:P5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: P5 modifier} - activate old Perl 5 regex rules, alias to *":Perl5"{link: Perl5 modifier}* * *{{$~P5Regex}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: p5regex var} - current "grammar"{link: grammar} of the Perl 5 compatible regular expression language * *"pack"{link: [Perl 6 Basics tablet] pack}* {section: pack} - repackage values into or from a condensed format * *package* _(block modifier)_ {section: package} - defines this Block or File as namespace (almost like in Perl 5), some uses are now better to do with *"module"{link: module}* and *"class"{link: class}* * *{{&?PACKAGE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: package compiler var} - reference to the current package * *package_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: package_declarator category} - internal namespace for - example: _"package"{link: package}, "module"{link: module}, "class"{link: class}_ * *Pair* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Pair type} - A single key-to-value association * *pair* _(context op)_ {section: pair} - force pair context * *pairs* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: pairs} - returns all contents as an array or pairs (key,value) * *PairSeq* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: PairSeq type} - A *"Seq"{link: Seq}* of *"Pairs"{link: Pair}* * *:panic* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: panic modifier} - overwriting a possible set *":ratchet"{link: ratchet modifier}* for all subrules (activates backtracking) * _parameter_ {section: parameter} - value passed to a method or subroutine, mostly as part of the signature * *Parcel* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Parcel type} - Arguments in a comma list * *parcel* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: parcel} - raw reference, will not be contextualized * *parsed* _"(routine trait)"{link: [perl 6 lookup tablet]routine traits}_ {section: parsed} - this macro will be parsed once, it is hygienic, but own and later defined rules can't be applied, opposite of *"reparsed"{link: reparsed}* * _parsetree_ {section: parsetree} - hierarchical data representing the logical structure of a program, also called _"AST"{link: AST}_ * *":path"{link: [Perl 6 Basics tablet] Paths}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: path adverb} - quote paths and create path object that know the right format of the current *"$*OSNAME"{link: osname global var}* with *{{Q :path /.../}}*, long for *":p"{link: p adverb}* * *"perl"{link: [Perl 6 Basics tablet] perl}* _(formater)_ {section: perl} - transforms data structure into Perl 6 source syntax; use *"eval"{link: eval}* onto that string and you get the data structure again; bit like _Data::Dump_ * *{{$*PERL}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: perl global var} - Perl version running under, was $] and $^V in Perl 5 * *{{$?PERL}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: perl compiler var} - Perl version compiled for * *:Perl5* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: Perl5 modifier} - activate old Perl 5 regex rules, alias to *":P5"{link: P5 modifier}* * *pick* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pick} - select a number (first parameter) of random vaues (without duplication), take *"roll"{link: roll}* to enable duplication * *{{$*PID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: pid global var} - ID of the running process, was $$ and $PID in Perl 5 * "phaser"{link: [perl_6_lookup_tablet] closure traits} {section: phaser} - Perl 6 term for specially named subblocks withe special runtimes aka closure traits - example: *"BEGIN"{link: BEGIN phaser}* * *pick* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pick} - selects randomly elements from this list, optional parameter says how many * _pipe_ {section: pipe} - connection between 2 processes, move data (mostly only in one direction) without buffering * _"POD"{link: [perl 6 basics tablet] pod}_ {section: POD} - Plain Old Documentation, a markup language to be embedded into Perl source code, has in Perl 6 ability to store data to be retrieved later * *{{$=pod}}* _"(special var)"{link: [perl 6 lookup tablet] POD Variables}_ {section: pod pod var} - surrounding _"POD"{link: POD}_ object * _pointy block_ {section: pointy block} - a block that is given parameters with *"->"{link: arrow op}* * *polar* {section: polar} - magnitude or angle corresponding to the complex number(only parameter); the magnitude is non-negative, and the angle in the "range"{link: range op} {-π ..^ π}} * *pop* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: pop} - removes and returns the last element in an array * *:pos*(<n>) _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: pos modifier} - searching only on the nth (n is an int) position (counting from 0), long for *":p"{link: p modifier}* * *POST* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: POST phaser} - marks a special block, assert postcondition, executed at every block exit, after *"LEAVE"{link: LEAVE phaser}* * *postcircumfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postcircumfix category} - operator namespace of ops, that stay after one statement or variable, but do surround a second - example(square brackets): _$a[2]_ * *postfix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postfix category} - operator namespace of ops, that stay after a statement or variable (like $a++) * *postfix_prefix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: postfix_prefix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "prefix"{link: prefix category} (precedes) other operator but stay "postfix"{link: postfix category} (after) another term - example (greater as): _@a >>++_ * *PRE* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: PRE phaser} - marks a special block, assert precondition, executed at every block entry, before *"ENTER"{link: ENTER phaser}* * *pred* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: pred} - returns the predecessor of $x (only parameter), alias to *--* operator, see also *"succ"{link: succ}* * *prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix category} - operator namespace of ops, that stay before a statement or variable - example: _"++$a"{link: plus plus}_ * *prefix_circumfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix_circumfix_meta_operator} - internal namespace of "metaoperator"{link: metaoperator} that "circumfix"{link: circumfix category} (surrounds) other operator but stay "prefix"{link: prefix category} (before) another term - example (square brackets): _{{[+] @a # sums up all elements of @a}}_ * *prefix_postfix_meta_operator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: prefix_postfix_meta_operator category} - internal namespace of "metaoperator"{link: metaoperator} that "postfix"{link: postfix category} other operator but stay "prefix"{link: prefix category} (before) another term - example (greater as): _++<< @a_ * *"pretty"{link: [Perl 6 Basics tablet] pretty}* _(formater)_ {section: pretty} - format data structures, optimized for human interpretation * *"print"{link: [Perl 6 IO tablet] print}* {section: print} - sends characters to an output stream (*"$*OUT"{link: out global var}*) without adding a newline, similar to *"say"{link: say}* * *"print"{link: [Perl 6 IO tablet] print for files}* _(handle method)_ {section: print io} - writes a stream into a file * *<print>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: print subrule} - a single printable character * *"printf"{link: [Perl 6 IO tablet] printf}* {section: printf} - formats text like *"sprintf"{link: sprintf}* and sends it to standard output like *"print"{link: print}* * *"<prior>"{link: [Perl 6 Lookup tablet] subrules}* {section: prior subrule} - standard grammar's rule for whatever the prior successful regex matched * *"prompt"{link: [Perl 6 IO tablet] prompt}* {section: prompt} - *"print"{link: print}* - ing text and reading the answer (a line from *"$*IN"{link: in global var}* - formerly _STDIN_) * _property_ {section: property} - metadata of a variable set at runtime * *proto* _"(routine modifier)"{link: [perl 6 lookup tablet] routine modifier}_ {section: proto} - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed * *<punct>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: punct subrule} - a single punctuation character * *push* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: push} - appends a list of values to the end of an array (see also *"pop"{link: pop}*) * *push* _"(hash op & method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ - inserts a list of "pairs"{link: Pair} in a Hash; if a key already exists, it will point to an array of both values |
|
* *Q* "(generalized quoting op)"{link: [perl_6_lookup_tablet] Quoting Ops} - understands a ";list of adverbs"{link: [perl_6_lookup_tablet] quoting_ops_and_adverbs} * *q* "(quoting op)"{link: [perl_6_lookup_tablet] Quoting Ops} - simple quoting (slashes and '), alias to '...' and Q :q /.../ and Q :single /.../ * *:q* "(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 * *quote* _(grammatical category)_ - operator namespace, used to define new quoting ops with a macro * *quote_mod* _(grammatical category)_ - operator namespace, used to define new quoting adverbs * *:quotewords* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), long form of ":quotewords", used in {{< ... > and << ... >>}} * *qq* "(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* "(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" * *quasi* _(block modifier)_ - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: code * *qw* "(quoting op)"{link: [perl_6_lookup_tablet] Quoting Ops} - splits result on words (as in P5), alias to Q :q :w // * *qx* "(quoting op)"{link: [perl_6_lookup_tablet] Quoting Ops} - execute as command and return results (as in P5), alias to Q :x // |
^^ "Q"{link: Index} {section: Q} |
|
^^ R |
* *"Q"{link: [Perl 6 Basics tablet] Quoting}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: capital Q op} - most basic quoting operator, understands a list of "adverbial modifier"{link: [perl_6_lookup_tablet] Quoting Adverbs} * *"q"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: q op} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *Q :q /.../* and *Q ":single"{link: single adverb} /.../* * *":q"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: q adverb} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *q /.../*, short for *":single"{link: single adverb}* * *\Q[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital Q} - all metacharacters within the brackets match as literal characters * *{{$~Q}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: q var} - current "grammar"{link: grammar} of the quoting language * *"qp"{link: [Perl 6 Basics tablet] Paths}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qp op} - path quoting, quoted string will be evaled as an file or directory path, alias to *Q ":p"{link: p adverb} /.../* and *Q ":path"{link: path adverb} /.../* * *"qq"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qq op} - _double quoting_, *q* with interpolation of variables, closures, and special chars, alias to *""...""{link: double quotation marks}* and *Q :s, :a, :h, :f, :c, :b /.../* and *Q* *":qq"{link: qq adverb}* */.../* and *Q* *":double"{link: double averb}* */.../* * *":qq"{link: [Perl 6 Basics tablet] Double Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: qq adverb} - _double quoting_, *q* with interpolation of variables and "blocks"{link: block}, alias to *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *Q :s, :a, :h, :f, :c, :b /.../*, short for *":double"{link: double adverb}* * *"qqx"{link: [Perl 6 basics tablet]Code}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qqx op} - run as system call and return results; was _qx/.../_ in Perl 5 * *quasi* _(block modifier)_ {section: quasi} - quasi quoting, the following commented will be compiles and the AST will be returned as result, see also: code * *{{$~Quasi}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: quasi var} - current "grammar"{link: grammar} of the quasiquoting language * *quote* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: quote category} - operator namespace, used to define new quoting ops with a macro * *quote_mod* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: quote mod category} - operator namespace, used to define new quoting adverbs * *":quotewords"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: quotewords adverb} - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and *""...""{link: double quotation marks}* sourrounded strings are taken as single words), long form of *":ww"{link: ww adverb}*, used in *"<<...>>"{link: double angle brackets}* * *"qw"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qw op} - splits result on words (as in Perl 5); alias to *Q :q :w /.../* or *"<...>"{link: angle brackets}* * *"qx"{link: [Perl 6 basics tablet]Code}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: qx op} - evaluate as Perl term (like *"eval"{link: eval}*) and return results (unlike Perl 5), alias to *Q ":x"{link: x adverb} /.../* or *Q ":exec"{link: exec adverb} /.../* |
|
* *R*<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* - generate a floating point random number between 0.0 and 1.0 * *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* "(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 * *parsed* "(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* "(loop block modifier)"{link: [perl_6_lookup_tablet] Loops} - initial command for while or until loops that have their condtion at the end * *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 method)_ - returns all the members in the opposite order. Use "flip" to turn a string back to front and "invert" for hashes * *rindex* - finds the last occurrence before a given position, of a substring within a string * *role* - container for methods that can extend a class using does * *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 * _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)_ |
^^ "R"{link: Index} {section: R} |
|
^^ S |
* *:R* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital R filetest} - check if file is readable by real uid/gid * *:r* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: r filetest} - check if file is readable by effective uid/gid * *\R* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital R} - anything but return * *\r* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash r} - return (CR), as in Perl 5 * *R*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: capital r metaop} - reverse operands * *rand* {section: rand} - pseudo random number in "range"{link: range op} _0 ..^ 1_ (including 0, but not 1); for random list choices see *"pick"{link: pick}* and *"roll"{link: roll}* * *Range* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: range type} - a pair of ordered endpoints, result of an evaluated term with the "range operator"{link: range op} * *RangeIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: rangeiter type} - Iterator over a *Range* * *Rat* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: rat type} - Perl rational number (exact *"Real"{link: real type}* numerator, limited denominator) * *:ratchet* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ratchet modifier} - deactivates backtracking, search starts at pos, where last match ended * <n> *:rd* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: rd modifier} - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd) * *"read"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: read} - read n (first parameter) bytes from a buffer * *"readline"{link: [Perl 6 IO tablet] readline}* {section: readline} - * *readonly* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: readonly} - immutable parameter * *redo* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: redo} - re-starts processing of the current loop turn * *reduce* _(list method)_ {section: reduce} - alias to *"[ ]"{link: square bracket metaop}* "metaoperator"{link: [perl 6 lookup tablet] metaoperators}: _{{ [+] @a = @a.reduce(&[+]) }}_ * _reference_ {section: reference} - address of data in memory, often termed a Capture in Perl 6 * *Regex* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: Regex type} - builtin type that holds a compiled regular expression * *regex* - _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: regex} - a pattern definition (without *":ratchet"{link: ratchet modifier}* and *":sigspace"{link: sigspace modifier}*), can be put in a *"grammar"{link: grammar}*, similar to qr/.../ in Perl 5, see *"rule"{link: rule}*, *"token"{link: token}* * *":regex"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: regex adverb} - parse as quoted string as regex * *{{$~Regex}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: regex var} - current "grammar"{link: grammar} of the regex language, tells the parser how to parse regular expressions * _regular expression_ {section: regular expression} - in Perl5: pattern matching notation, either regex, token or rule in Perl6 * *reparsed* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: reparsed} - after parsing this *"macro"{link: macro}*, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of *"parsed"{link: parsed}* * *"repeat"{link: [Perl 6 Block tablet] repeat}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: repeat} - initial command for *"while"{link: while}* or *"until"{link: until}* loops that have their condition at the end * *"rename"{link: [Perl 6 IO tablet] rename}* {section: rename} - changes names of files and directories * *return* _"(flow control)"{link: [perl 6 lookup tablet] jump commands}_ {section: return} - leaves a subroutine and sets the return value * *returns* {section: returns} - sub trait describing the type of value produced by a function * *reverse* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: reverse} - returns all the members in the opposite order. Use *"flip"{link: flip}* to turn a string back to front and *"invert"{link: invert}* for hashes * *rindex* _(string method)_ {section: rindex} - finds the last occurrence of a substring in a string and returns the numerical position, opposite or *"index"{link: index}* * *"rmdir"{link: [Perl 6 IO tablet] rmdir}* {section: rmdir} - deletes a directory with given name * *role* {section: role} - container for methods that can extend a class using *"does"{link: does}* * *{{$?ROLE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: role compiler var} - current role object * *{{::?ROLE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: role package compiler var} - name of the current role * *roll* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: roll} - selects <n> (first parameter) values from an array, duplication can occur (like rolling dice), *"pick"{link: pick}* works without duplication * *roots* {section: roots} - (Num $f, Int $n) compute the $n'th root of $f * *"rotate"{link: [Perl 6 Variable Tablet]}* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: rotate} - put some elements (number is first parameter) of a list to the end; rotates backward with negative parameter; _{{@a .= rotate;_ is alias to _@a.push: @a.shift;}}_ * *round* {section: round} - returns the nearest integer of only parameter * *roundrobin* _"(array method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: roundrobin} - kind of *"zip"{link: zip}* that ignores empty lists - example: _{{roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3}}_ * *{{&?ROUTINE}}* _"(special var)"{link: [perl 6 lookup tablet] Compiler Hint Variables}_ {section: routine compiler var} - current routine object * *Routine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: routine type} - base class for all "wrappable"{link: wrap} executable objects libs *"sub"{link: sub}*, *"method"{link: method}* and alike * *routine* {section: routine} - * *routine_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: routine_declarator category} - internal namespace for "routine declarators"{link: [perl_6_lookup_tablet]Routine Types} - example: _"sub"{link: sub}, "method"{link: method}_ * *rule* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: rule} - alias for _*"regex"{link: regex}* *":ratchet"{link: ratchet modifier}* *":sigspace"{link: sigspace modifier}*_ in a grammar, see *"regex"{link: regex}*, *"token"{link: token}* * *"run"{link: [Perl 6 IO Tablet] Processes}* {section: run} - executes an external program, and returns control to the caller once the program has exited * *"runinstead"{link: [Perl 6 IO Tablet] Processes}* {section: runinstead} - executes an external program that replaces the caller, because there will be no return * _runtime_ {section: runtime} - time when software is being used (not compiletime), or software components necessary for that, or length of time to execute * *rw* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: rw routine trait} - marks a subroutine as returning an lvalue * *rw* _"(parameter trait)"{link: [perl 6 lookup tablet] parameter traits}_ {section: rw parameter trait} - mutable parameter (rw stands for: read write) * *:rw* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: rw modifier} - gives the regex the right to change the string (operand) * *"rx"{link: [Perl 6 Regex Tablet] Regex Operators}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: rx} - creates anonymous regex, that can me then assigned into a var, alias to *"Q"{link: capital Q op}* *":regex"{link: regex adverb}* */.../* and *"regex"{link: regex}* _(routine type)_ |
|
* *S*<op> "(meta op)"{link: [perl_6_lookup_tablet] Metaoperators} - force sequential (synchronous) evaluation, ; suppresses any explicit or implicit parallelism * *s* "(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" * *: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* - a function like print that also appends a newline (\n) * *Scalar* "(mutable type)"{link: [perl_6_lookup_tablet] mutable types} - Perl scalar, variable that holds a single value * *scalar()* "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers} - forces scalar context, alias to *$()* * *:scalar* "(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)_ - 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 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* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q" * *slice* _(list method)_ - forces slice context on a value, meaning a list which values are not contextualized further (can be lists themthelves); alias to {{ @@ }} "(conext op)"{link: [perl_6_lookup_tablet] Contextualizers} * _slice_ - part of an array or list * *Slicel* - "(immutable type)"{link: [perl_6_lookup_tablet] immutable_types} - Arguments in a semicolon list (or equiv, like Z) * *slurp* (io op and file handle method) - reads a entire file into a string * _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)_ - namespace to define and redefine special variables with a macro * *split* - makes an array of substrings from a string and a separator * *sprintf* - like printf but returns the string instead of outputting it * *ss* "(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* - declares variables known only in the enclosing block, that 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* _(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* _(quote op)_ - scalar method to perform substitution, alias to s/// * *:subst* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - parse as substitution * *substr* - the scalar substring function like in Perl 5 * *supersede* - replace all method and attribute definitions of a class/grammar |
^^ "S"{link: Index} {section: S} |
|
^^ T |
* *S*<op> _"(meta op)"{link: [Perl 6 lookup tablet] Metaoperators}_ {section: S} - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism * *"s///"{link: [Perl 6 Regex Tablet] Regex Operators}* _"(regex quoting op)"{link: [Perl 6 lookup tablet] Quoting Ops}_ {section: s op} - perform a substitution based on rx-matches in place, creates anonymous regex, alias to *Q :subst /.../.../* and *".subst()"{link: subst}* _(string method)_ * *:S* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ {section: capital S filetest} - file is a socket * *:s* _"(filetest op)"{link: [Perl 6 Lookup tablet] Filetest Ops}_ {section: S filetest} - file has size greater than 0 (zero) * *:s* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: s adverb} - demands evaluation of scalar variables that start with the *"$-sigil"{link: dollar sigil}*, long form of *":scalar"{link: scalar adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * *:s* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: s modifier} - whitespace separates now subregex and don't stand for spaces to look for, short for *":sigspace"{link: sigspace modifier}*, *"ms/.../"{link: ms op}* is alias to *m:sigspace/.../* * *\S* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital S} - anything but whitespace * *\s* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash s} - any whitespace character, horizontal ( *"\h"{link: backslash h}* ) and vertical ( *"\v"{link: backslash v}* ) * *<?same>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: same subrule} - match the zero-width space between two identical chars * *:samecase* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: samecase modifier} - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for *":ii"{link: ii modifier}* * *:samemark* _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: samemark modifier} - substitute with chars that has same mark/accent pattern as the matched string, long for ":mm" * *:samespace* _"(regex modifier)"{link: [Perl 6 lookup tablet] Regex Modifier}_ {section: samespace modifier} - smart space mapping for substitutions, long for *":ss"{link: ss modifier}*, *"ss/.../.../"{link: ss op}* is alias to *s:samespace/.../.../* - example: _ss/teh hsa/the has/;_ * *"say"{link: [Perl 6 IO tablet] say}* {section: say} - makes output via command line (*"$*OUT"{link: out global var}*) like *"print"{link: print}*, but appends a newline (*"\n"{link: backslash n}*) * *"say"{link: [Perl 6 IO tablet] say for files}* _(handle method)_ {section: say io} - writes a stream into a file and appends *"\n"{link: backslash n}* * *Scalar* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: scalar type} - object to hold a Perl scalar, a variable for a single value * *":scalar"{link: [Perl 6 basics tablet]Interpolation}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: scalar adverb} - demands evaluation of scalar variables that start with the *"$-sigil"{link: dollar sigil}*, long form of *":s"{link: s adverb}*, included in *""...""{link: double quotation marks}*, *"qq/.../"{link: qq op}* and *"<<...>>"{link: double angle brackets}* * _scope_ {section: scope} - the block of code within which an identifier is usable * *scope_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: scope_declarator category} - internal namespace for "scope declarators"{link: [perl_6_lookup_tablet]Scope Declarator} - example: _"my"{link: my}, "our"{link: our}, "has"{link: has}, "state"{link: state}_ * *seed* {section: seed} - initialize a random number generator, optionally with a value * *Seq* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Seq type} - A list of values (can be generated lazily) * *SeqIter* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: SeqIter type} - Iterator over a Seq * *Set* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Set type} - unordered collection of values that allows no duplicates * *set* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: set} - creates a Set * *sigil* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: sigil category} - word to name the namespace for sigils, used to redifine them or define your own with a macro * _sigil_ {section: sigil} - character that serves as a prefix to categorize the following name, most prominent in Perl are the variable "sigils"{link: [perl 6 lookup tablet] Sigils}: *"$"{link: dollar sigil}*, *"@"{link: at sigil}* and *"%"{link: percent sigil}* * *sign* {section: sign} - 1 when $x (only parameter) > 0, -1 if < 0, 0 when = 0, undefined when undefined * *Signature* - _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: signature type} - object type to hold all information a signature like parameter types and values, return type, etc. * *signature* _(routine method)_ {section: signature} - returns a capture object with the signature of this routine * *signature* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: signature routine trait} - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type * _signature_ {section: signature} - function parameters (left-hand side of a binding), surrounded by round parentheses * *:sigspace* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: sigspace modifier} - whitespace separates now subregex and don't stand for spaces to look for, long for for *":s"{link: s modifier}*, *"ms/.../"{link: ms op}* is alias to *m:sigspace/.../* * *"sin"{link: [Perl 6 Operator Tablet]}* _"(numeric op)"{link: [Perl 6 Operator Tablet] numeric context}_ {section: sin} - sine, trigonometric function, takes angle in radian; see also *"to-radians"{link: to-radians}*, *"cos"{link: cos}*, *"tan"{link: tan}* * *":single"{link: [Perl 6 Basics tablet] Single Quotes}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: single adverb} - simple quoting (slashes and '), alias to *"'...'"{link: single quotation marks}* and *"q/.../"{link: q op}*, long for *":q"{link: q adverb}* * *sleep* {section: sleep} - attempt to sleep for up to Num $for seconds (with sub-second resolution) * _slice_ {section: slice} - part of an array or list * *slang* {section: slang} - sublanguages of Perl 6, their grammar is mostly stored in "special variables"{link: [perl 6 lookup tablet] Special Variables} with the "twigil"{link: twigil} ~, such as *"$~Regex"{link: regex var}* or *"$~MAIN"{link: main var}* (main language); you can change or alter them with this keyword by using the _augment_ or _supersede_ command * *"slurp"{link: [Perl 6 Basics tablet] Files}* _(path|file handle method)_ {section: slurp} - reads an entire file into a string without a file handle * _slurpy array_ {section: slurpy array} - array parameter that receives all (slurps) all optional subroutine arguments * *so* _(op)_ {section: so op} - converts value into the boolean context, low precedence alternative to *"?"{link: question mark op}* * *SoftRoutine* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: softroutine type} - A routine that is committed to staying mutable * *<space>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: space subrule} - single white space char aka *"\s"{link: backslash s}* * *special_variable* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: special_variable category} - namespace to define and redefine "special variables"{link: [perl 6 lookup tablet] Special Variables} with a macro * *splice* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: splice} - remove on $pos (first parameter) $n (second - optional) values and replace them with values (third - optional) * *split* {section: split} - makes an array of substrings from a string and a separator * *"sprintf"{link: [Perl 6 Basics tablet] sprintf}* _(formater)_ {section: sprintf} - inserts formated values out of variables into a string like *"printf"{link: printf}*, but returns the string instead of outputting it * *sqrt* {section: sqrt} - square root of $n (Num - first and only parameter) * *"ss///"{link: [Perl 6 Regex Tablet] Substitution}* _"(regex quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: ss op} - performs *"rx"{link: rx}* based substitution, spaces are just subrule separators, alias to *s:ss/.../.../*, e.g.: ss/teh hsa/the has/; * *:ss* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: ss modifier} - only for for substitution, whitespace separates subregexes like *":sigspace"{link: sigspace modifier}*, but also in the second part, short for *":samespace"{link: samespace modifier}* * <n> *:st* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: st modifier} - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st) * *START* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: START phaser} - marks a special block or statement, executed on first ever execution, once per closure clone * *Stash* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: stash type} - A symbol table hash (package, module, class, lexpad, etc) * *stat* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: stat} - available information about a file or link (call _stat :link_ as former lstat) * *state* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: state} - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations) * *statement_control* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_control category} - internal namespace for block modifier like "conditionals"{link: [perl 6 lookup tablet]Conditionals} or "loops"{link: [perl 6 lookup tablet]Loops} that stay in front of it * *statement_mod_cond* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_mod_cond category} - internal namespace for words that come after a statement and handle if the statement will be executed - example : _*$a++ "if"{link: if}* $a > 3_ * *statement_mod_loop* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_mod_loop category} - internal namespace for "special group of block modifier"{link: [perl 6 lookup tablet]Loops} that turn the "block"{link: block} into a loop - example : _*"loop"{link: loop}*, *"repeat"{link: repeat}*, *"for"{link: for}*_ * *statement_prefix* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: statement_prefix category} - internal namespace for block modifier - example : _*"do"{link: do}*_ * *Str* _"(immutable type)"{link: [perl 6 lookup tablet] immutable types}_ {section: Str type} - Perl string (finite sequence of Unicode characters) * *Sub* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: sub type} - Perl subroutine object * *"sub"{link: [Perl 6 Block tablet] sub}* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: sub} - defines a subroutine, a block callable by name * *Submethod* _"(mutable type)"{link: [perl 6 lookup tablet] mutable types}_ {section: submethod type} - Perl subroutine acting like a method * *submethod* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: submethod} - defines methods, not inherited by subclasses * _subroutine_ {section: subroutine} - block of code callable by name * *subset* {section: subset} - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 } * *":subst"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: subst adverb} - parse as "substitution regex"{link: [Perl 6 Regex Tablet] Substitution}, *Q :subst /.../.../* is alias to *"s/.../.../"{link: s op}* * *"subst"{link: [Perl 6 Regex Tablet] Substitution}* _(string method)_ {section: subst} - method alias to {{ s/.../.../, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/; }} * *substr* _(string method)_ {section: substr} - the scalar substring function like in Perl 5 * *succ* _"(sequence traversion)"{link: [perl 6 Operator tablet] Traversing Sequence}_ {section: succ} - returns the successor of $x (only parameter), alias to *++* operator (see *"pred"{link: pred}*) * *supersede* _"(scope declarator)"{link: [perl 6 lookup tablet] Scope Declarator}_ {section: supersede} - replaces definitions of an existing name, e.g. methods and attributes of a *"class"{link: class}* or *"grammar"{link: grammar}*, see also: *"augment"{link: augment}* |
|
* *:t* "(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* - produces a return value in a gather block * *temp* - defines variables as temporary, synonym for the Perl 5 "local" * *term* _(grammatical category)_ - namespace of terms, used to redifine them or make a new with a macro * <n> *:th* "(regex modifier)"{link: [perl_6_lookup_tablet] Regex Modifier} - 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 higher than an existing operator ("as seen here"{link: [perl_6_lookup_tablet] table_of_precedence}) * *:to* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - defines end marker for the following heredoc, :to is short for :heredoc * *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* "(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* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - evals the quoted as transliteration aka tr /// * *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)_ - word to name the namespace for twigils, used to redifine them or define your own with a macro |
^^ "T"{link: Index} {section: T} |
|
^^ U |
* *:t* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: t filetest} - filehandle is opened to a tty (terminal) * *\T* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital T} - anything but a tab * *\t* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash t} - tab, not visible character * *"take"{link: [Perl 6 Block Tablet ]gather and take}* {section: take} - can add several item to the list of return values of a *"gather"{link: gather}* block * *tan* _"(numeric op)"{link: [perl 6 Operator Tablet] numeric context}_ {section: tan} - tangent, trigonometric function, takes angle in radian; see also *"to-radians"{link: to-radians}*, *"cos"{link: cos}*, *"sin"{link: sin}* * *temp* {section: temp} - defines variables as temporary, synonym for the Perl 5 _local_ * *term* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: term category} - namespace of terms, used to redifine them or make a new with a macro * <n> *:th* _"(regex modifier)"{link: [perl 6 lookup tablet] Regex Modifier}_ {section: th modifier} - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd) * *tighter* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: tighter} - specifies the "precedence of an operator"{link: [perl 6 lookup tablet] table of precedence} higher than an existing operator * *":to"{link: [Perl 6 basics tablet]Heredocs}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: to adverb} - defines end marker for the following heredoc, *:to* is short for *":heredoc"{link: heredoc adverb}* * *to-radians* {section: to-radians} - convert from $base (second parameter) to radians, opposite of *"from-radians"{link: from-radians}* * *token* _"(routine type)"{link: [perl 6 lookup tablet] Routine Types}_ {section: token} - *"regex"{link: regex}* method without backtracking, alias to _*"regex"{link: regex}* *":ratchet"{link: ratchet modifier}*_ , part of a *"grammar"{link: grammar}* , see also *"rule"{link: rule}* * _topicalizer_ {section: topicalizer} - every keyword that sets the *"$_"{link: context var}* variable, eg given, for * *touch* (filehandle method) {section: touch} - update timestamps on a file (like the Unix command) * *"tr///"{link: [Perl 6 Regex Tablet] Transliteration}* _"(quoting op)"{link: [perl 6 lookup tablet] Quoting Ops}_ {section: tr op} - transliteration (as in Perl 5), translating some character in a string into others, alias to *Q :trans /.../.../* * _trait_ {section: trait} - additional property of a variable, defined at compile time, see *"but"{link: but}*, what other languages call _trait_ Perl calls "role"{link: role} * *trait_auxiliary* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: trait_auxiliary category} - * *trait_verb* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: trait_verb category} - example : *"of"{link: of}* * *":trans"{link: [Perl 6 Basics Tablet] Regex}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: trans adverb} - evals the quoted as "transliteration"{link: [Perl 6 Regex Tablet] Transliteration} aka tr /.../.../ aka .trans("..." => {{"..."}}) * *"trans"{link: [Perl 6 Regex Tablet] Transliteration}* _(string method)_ {section: trans} - method name for *"tr/.../.../"{link: tr op}* operator, $str.trans( %mapping ) equals {{$str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;}} * *{{$~Trans}}* _"(special var)"{link: [perl 6 lookup tablet] Slang Variables}_ {section: trans var} - current "grammar"{link: grammar} of the transliteration language (used by *trans()* aka *"tr/.../.../"{link: tr op}*) * *triangle* _(list method)_ {section: triangle} - alias to *"[\ ]"{link: square bracket slash metaop}* "metaoperator"{link: [perl_6_lookup_tablet] metaoperators} - example: {{ [\+] @a = @a.triangle(&[+]) }} * *True* {section: True} - boolean value aka Bool::True, 1 in numeric context * *truncate* _(num op)_ {section: truncate} - closest integer to $f (only parameter) whose absolute value is not greater than the absolute value of $f * *trusts* {section: trusts} - allows a class the acess to otherwised sealed namespaces * *twigil* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: twigil category} - internal namespace for "twigils"{link: [Perl 6 Variable Tablet] Twigils}, used to redifine them or define your own with a macro * _"twigil"{link: [perl 6 lookup tablet] Twigils}_ {section: twigil} - second(ary) _"sigil"{link: sigil}_ indicating a special property of a variable * *type_declarator* _"(grammatical category)"{link: [perl 6 lookup tablet] Categories}_ {section: type_declarator category} - - example: *"subset"{link: subset}* * *{{$*TZ}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: tz global var} - local time zone |
|
* *:u* "(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* "(block modifier)"{link: [perl_6_lookup_tablet] Conditionals} - flow control modifier, opposite of if, runs block if expression is false * *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* - load a module, import definitions, check Perl version |
^^ "U"{link: Index} {section: U} |
|
^^ V |
* *:u* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: u filetest} - report if file has setuid bit set * *\U[<n>]* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital U} - everything within the brackets is uppercase * *uc* {section: uc} - make all string chars uppercase * *ucfirst* {section: ucfirst} - make first char of a string uppercase * *{{$*UID}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: uid global var} - real user ID of the running process (*"$*PID"{link: pid global var}*) owner (user), was @< and $UID in Perl 5 * *UNDO* _"(closure trait)"{link: [perl 6 lookup tablet] closure traits}_ {section: UNDO} - marks a special block, executed at every unsuccessful block exit, part of *"LEAVE"{link: LEAVE phaser}* queue * *uniq* _(list method)_ {section: uniq} - only unique elements of a list * *"unless"{link: [Perl 6 Block tablet] unless}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: unless} - flow control modifier, opposite of if, runs block if expression is false * *"until"{link: [Perl 6 Block tablet] until}* _"(block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: until} - opposite of while, runs block repeatedly is long as expression is false * *unwrap* {section: unwrap} - remove an enclosing subroutine (see *"wrap"{link: wrap }*) * *<upper>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: upper subrule} - a single uppercase character * *"uri"{link: [Perl 6 IO Tablet] }* {section: uri} - returns IO::Streamable descendant for accessing content of that URI (only pramameter typed Str) * *"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* "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)_ - gets value (second) value of a pair * *values* _(hash method)_ - returns an array of just the values |
^^ "V"{link: Index} {section: V} |
|
^^ W |
* *\V* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital V} - anything but vertical whitespace * *\v* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash v} - vertical whitespace (LF + CR + FF + Line Tab + Next Line + Line Separator + Paragraph Separator), see also *"\s"{link: backslash s}* (whitespace) * *value* _"(pair method)"{link: [Perl 6 Variable Tablet] Pair}_ {section: value} - gets value (second) value of a pair (opposite of *"key"{link: key}*) - example: (key => 'value').value; # returns 'value' * *values* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: array values} - returns an array of values like the var itself in "list context"{link: list context} does * *values* _"(hash method)"{link: [Perl 6 Variable Tablet]Hash Methods}_ {section: values} {section: values hash} - returns an array of just the values - example: _(1 => 2, 3 => 4).values; # returns (2,4)_ * *{{$*VM}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: vm global var} - name of running virtual machine * *{{$?VM}}* _"(special var)"{link: [perl 6 lookup tablet] Global Variables}_ {section: vm compiler var} - name of virtual machine compiled for |
|
* *: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* "(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 "_") * *want* - produces a signature object that provides information about the context from which the current routine was called * *warn* - prints a message on $*ERR * *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* "(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* "(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* "(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// * *wrap* - creates enveloping subroutine * *:ww* "(quoting adverb)"{link: [perl_6_lookup_tablet] Quoting Adverbs} - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), short form of ":quotewords", used in {{< ... > and << ... >>}} |
^^ "W"{link: Index} {section: W} |
|
^^ X |
* *:W* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: capital w filetest} - check if file is writeable by real uid/gid * *:w* _"(filetest op)"{link: [perl 6 lookup tablet] Filetest Ops}_ {section: w filetest} - check if file is writeable by effective uid/gid * *":w"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: w adverb} - split quoted string on words (on whitespaces), no quote protection, short form of *":words"{link: words adverb}*, used in *"qw/.../"{link: qw op}* * *\W* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital W} - anything but a word character * *\w* _"(escape sequence)"{link: [perl 6 lookup tablet] Escape Sequences}_ {section: backslash w} - word character (Unicode alphanumeric plus "_") * *"wait"{link: [Perl 6 IO Tablet] Processes}* {section: wait} - waits for a child process to terminate and returns the child status object, process ID in numeric context * *want* {section: want} {section: want} - produces a signature object that provides information about the context from which the current routine was called * *"warn"{link: [Perl 6 IO tablet] warn}* {section: warn} - makes output via standart error output ($ERR - usually the command line), similar to *"note"{link: note}*, but works more like *"print"{link: print}*, without appending *"\n"{link: backslash n}* * *<wb>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: wb subrule} - zero-width word boundary between an *"\w"{link: backslash w}* and a *"\W"{link: backslash capital w}* character aka *"\b"{link: backslash b}*, see also *"<ww>"{link: ww subrule}* * *WHAT* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHAT introspection} - short name of the class that an object belongs to * *Whatever* _"(undefined value type)"{link: [perl 6 lookup tablet] Undefined types}_ {section: Whatever} - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch), alias to *"*"{link: asterisk}* * *WHEN* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHEN introspection} - (reserved for events?) * *"when"{link: [Perl 6 Block tablet] when}* _"(block modifier)"{link: [perl 6 lookup tablet] Conditionals}_ {section: when} - executes its following code block, when parameter matches against *"$_"{link: context var}* (set by *"given"{link: given}* or *"for"{link: for}*); (see also *"default"{link: default}*) * *WHENCE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHENCE introspection} - autovivification of closures * *WHERE* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHERE introspection} - memory address of the object * *where* {section: where} - defines subtypes of data - example: _{{subset Month of Int where { 1 <= $^a <= 12 } }}_ * *WHICH* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHICH} - object ID (type) * *"while"{link: [Perl 6 Block tablet] while}* _"(loop block modifier)"{link: [perl 6 lookup tablet] Loops}_ {section: while} - flow control modifier runs block repeatedly as long as en expression is *"True"{link: true}* * *WHO* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHO introspection} - package, that support that object, long name in string context * *WHY* _"(introspection method)"{link: [perl 6 lookup tablet] object introspection}_ {section: WHY introspection} - reserved for documentation, see also *"#="{link}* * *will do* _"(routine trait)"{link: [perl 6 lookup tablet] routine traits}_ {section: will do} - block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition * *words* _(string method)_ {section: words} - splits a sting into a list of words - example: _{{ $input.words($limit) equals $input.comb( / \S+ /, $limit ) }}_ * *":words"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: words adverb} - split quoted string on words (on whitespaces), no quote protection, long form of *":w"{link: w adverb}*, used in *"qw/.../"{link: qw op}* * *wrap* {section: wrap} - creates enveloping subroutine (see also *"unwrap"{link: unwrap}*) * *"write"{link: [Perl 6 IO tablet] read}* _(Buf method)_ {section: write} - writes content of all parameter into that buffer * *<ws>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: ws subrule} - whitespace between words aka *"\s*"{link: backslash s}* * *":ww"{link: [Perl 6 Basics tablet] Quote Words}* _"(quoting adverb)"{link: [perl 6 lookup tablet] Quoting Adverbs}_ {section: ww adverb} - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and *""...""{link: double quotation marks}* sourrounded strings are taken as single words), short form of *":quotewords"{link: quotewords adverb}*, used in *"<<...>>"{link: double angle brackets}* * *{{<ww>}}* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: ww subrule} - zero-width space inside of a word between two *"\w"{link: backslash w}* character, see also *"<wb>"{link: wb subrule}* |
|
* *X* _(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* _(scalar string op)_ - 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 executed 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* _(scalar bool op)_ - boolean exclusive or operator, only true if only one operand is true * *xx* _(scalar string op)_ - string replicate operator to array, eg 'ab' xx 3 == <ab ab ab> |
^^ "X"{link: Index} {section: X} |
|
^^ Y |
* *X* _(list op)_ {section: capital X} - Cross product of two arrays, alias of *"cross"{link: cross}* method - example: _1,2 X 3,4 == 1,3,1,4,2,3,2,4;_ * *x* _"(string op)"{link: [perl 6 Operator tablet] String Context}_ {section: x} - string replicate operator to single string - example: _'ab' x 3 == 'ababab';_ * *X*<op> _"(meta op)"{link: [Perl 6 lookup tablet] Metaoperators}_ {section: capital x metaop} - Cross product with hyper operator, alias of *"crosswith"{link: crosswith}* method - example: _<a b> X~ <y z> == <ay az by bz>;_ * *:X* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: capital x filetest} - check if file is executable by real uid/gid * *:x* _"(filetest op)"{link: [Perl 6 lookup tablet] Filetest Ops}_ {section: x filetest} - check if file is executable by effective uid/gid * *:x* _"(quoting adverb)"{link: [Perl 6 lookup tablet] Quoting Adverbs}_ {section: x adverb} - quoted string will be evaluated as Perl code (like *"eval"{link: eval}*) and replaced with its result, alias to *"Q"{link: capital q op}* *":exec"{link: exec adverb}* */.../* and *"qx/.../"{link: qx op}* * *:x*(<n>) _"(regex modifier)"{link: [Perl 6 lookup tablet]Regex Modifier}_ {section: x modifier} - searching n times (n is an int) with this pattern * *\X[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash capital X} - anything but the character given in hexadecimal (brackets optional) * *\x[<n>]* _"(escape sequence)"{link: [Perl 6 lookup tablet] Escape Sequences}_ {section: backslash x} - character given in hexadecimal (brackets optional) * *<xdigit>* _"(predefined subrule)"{link: [Perl 6 Lookup tablet] subrules}_ {section: xdigit subrule} - single hexadecimal digit char * *xor* _"(logical op)"{link: [perl 6 Operator tablet] logical selection}_ {section: xor} - "infix"{link: infix category} logical _eXclusive OR_ operator (_XOR_), *"True"{link: true}* if only one side has positive value, returns otherwise left value, low precedence version of *"^^"{link: double caret op}* * *xx* _"(infix list op)"{link: [perl 6 Operator tablet] List generation}_ {section: xx} - replicate a list _$n_ (second operand) times - example: `{{ 'ab' xx 3 = <ab ab ab> }}` |
|
* _yadda operator_ - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: ..., ??? and !!! |
^^ "Y"{link: Index} {section: Y} |
|
^^ Z |
* _yadda operator_ {section: yadda operator} - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: *"..."{link: triple dot yadda op}*, *"???"{link: triple question mark}* and *"!!!"{link: triple exclamation mark}* |
|
* *Z* _(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* _(list op & method)_ - 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(&[~]) } }} |
^^ ";Z"{link: Index} {section: Z} |
|
{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} |
* *Z* _(list op)_ {section: capital Z} - alias to zip _(list op)_ , joines 2 lists - example: _1,2,3,4 Z 8,9 == 1,8,2,9_ * *Z*<op> _"(meta op)"{link: [perl 6 lookup tablet] Metaoperators}_ {section: capital Z metaop} - joines the values from same position of 2 lists with following operator and produces in that manner a new list * *zip* _"(array op & method)"{link: [Perl 6 Variable Tablet]Array Methods}_ {section: zip} - zip operator, joines 2 lists, alias to *Z* operator - example: _{{ @a Z @b = (@a; @b).zip }}_ * *zipwith* _(list method)_ {section: zipwith} - alias to *"Z metaoperator"{link: capital z metaop}* - example: _{{ @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) } }}_ {link: A} | {link: B} | {link: C} | {link: D} | {link: E} | {link: F} | {link: G} | {link: H} | {link: I} | {link: J} | {link: K} | {link: L} | {link: M} | {link: N} | {link: O} | {link: P} | {link: Q} | {link: R} | {link: S} | {link: T} | {link: T} | {link: U} | {link: V} | {link: W} | {link: X} | {link: Y} | {link: Z} |
|
|
|
| ---- | ---- |
|
|
|
|
"Overview"[Perl 6 Tablets] - _Chapter:_ "0:Intr"[Perl 6 Intro Tablet], "1:Hist"[Perl 6 History Tablet], "2:Design"[Perl 6 Language Design 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] - _Appendices:_ *"A:Index"[Perl 6 Index Tablet]*, "B:Tables"[Perl 6 Lookup Tablet], "C:Best of"[Best Of Perl 6 Tablet], "D:Delta"[Perl 6 Delta Tablet], "E:Links"[Perl 6 Links Tablet] |
"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] |
| ---- | ---- |
|
|
|
