|
Perl 6
Perl Table Index: Revision 33
{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 short explanations for all Operators, Methods, Builtins and some technical Terms. * *!* - logic negation, forces binary context; * *!* - secondary Sigil of privat class variables * *!!* - second Part of the des ternary operator * *!!!* - yadda Operator * *!* - synonym for ">=" * *!=* - weird synonym for ">" * *!=* - compare op, true if numeric unequal, short for "!==" * *!=:=* - compare op, pr�ft negiert auf Binding * *!==* - compare op, pr�ft Ungleichheit im numerischen Kontext, negated form * *!===* - compare op, pr�ft Identit�t, negierte Form * *!>* - synonym for "<=" * *!>=* - synonym for "<" * *!~~* - negated smartmatch operator * *!eq* - synonym for "ne" * *!eqv* - negierte Form, der dynamischen Eqvivalenz * *!ge* - synonym for "lt" * *!gt* - synonym for "le" * *!le* - synonym for "gt" * *!lt* - synonym for "ge" * *#* - leitet Kommentar ein der bis zum Ende der Zeile geht * *$* - Sigil der Skalare; dereferenziert * *%* - gibt Rest einer Modulo-Division, erzingt numerischen Kontext; Sigil der Hashes * *&* - junctives and, verlangt das alle Bedingungen erf�llt sind; liefert subref * *&&* - logisches and, verkn�pft Aussagen, beendet Auswertung bei erstem Ausdruck mit unwahrem, leerem Ergebnis und liefert es zur�ck * *()* - Gruppierung von Werten (Parametern) * * - multipliziert Zahlen und erzwingt numerischen Kontext; kennzeichnet slurpy Arrays in Signaturen; sekund�re Sigil globaler Variablen; synonym for Inf in Verbindung mit einem Bereichsoperator (".."); kennzeichnet Ende eines Arrays im Sliceopertor um auf Indizes relativ vom Ende des Arrays zuzugreifen * ** - potenziert Zahlen und erzwingt numerischen Kontext * *+* - forces numeric context of operands and adds results * *+&* - bitweises und, numerisc context * *++* - autoincrement * *+<* - shift left, numeric context * *+>* - shift right, numerischer context * *+^* - bitwise xor, numeric context * *+|* - bitwise or, numeric context * *,* - list generating operator * - - forces numeric context and subtract * *--* - autodecrement * *-->* - alternativer Syntax um Parameter zu typisieren * -> weist Block benannte Parameter zu (pointy block) * *.* - sekundary sigil for public accessors (getter/setter) * *..* - range generating operator; range object in scalar context, see smartmatch table * *...* - yadda Operator * */* - Division, numerischer Kontext * *//* - err Operator, liefert ersten definierten Wert * *:* - konvertiert Dezimalzahl auf andere Basis; pair generation operator * *::* - Namespacetrenner wie in Perl5 * *::=* - Binding zur Compiletime * *:=* - erzeugt Alias auf Variable (Binding) * *;* - trennt Befehle (Ausdr�cke) oder Arrayindizes wie z.B. @a[2;3] statt @a[2]3 * *<* kleiner als, numerischer Vergleichsoperator * *<>* double pointy Syntax um einem Block `rw` Parameter zuzuweisen* * *<<* - wendet den Operator links als Hyperoperator auf den Array rechts an * *<==* - linker feed-Operator im append-mode * *>* - circumfixer Operator zum gruppieren mit autoquoting (vormals qw()), jedoch interpolierend wie "" * *<=* - kleiner gleich, numerischer Vergleichsoperator * *<==* - nach links zuweisender feed-Operator * *<=>* - numerischer Vergleichsoperator, benutzt Order Klasse * *< >* circumfixer Operator zum gruppieren mit autoquoting (vormals qw()) * *=* - assignment * *=:=* - compares binding * *==* - equality of value (numeric) * *===* - equality of value and type * *==>* - rightward pointing feed operator * *==>>* - feed operator, that adds values to an existing list (append-mode) * *>* - greater than, numeric comparison operator; ends grouping with autoquoting (formerly qw()) * *>=* - greater than or equal, numeric comparison Op * *>>* - binds operator (right) as hyper operator to an array (left) * *?* - forces binary context in an expression * *?* - marks optional parameters in signatures * *?* - quantifier for 0 or 1 occurrence in Regexes * *?* - secondary sigil for constant compiler hint variables * *?&* - logical op, and combinator, forces binary context * *?? !!* - ternary operator * *???* - yadda operator * *?^* - logical xor, forces operands into boolean context * *?|* - logical or, forces operands into boolean context * *@* - sigil of an array * *@@* - sigil for multislice context, meaning an array that may contain array references * *[]* - postcircumfix operator that creates an array reference, when it encloses a list; after an array name takes a list of subscripts and returns a partial array (slice) consisting of the subscripted values * *[]* - reduction metaop, close to functional "reduce" * *\* - capture operator, creates a reference to the following structure * *^* - junctive xor, requires that one value in a list is true, in ranges excludes the end value. in scalar context see smartmatch, in array context see array creating operators; twigil for automatically named parameters of a block * *^^* - logical xor, combines expressions, returns true when only one expression is true, otherwise false * *{ }* - circumfix operator: encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a '=>' * *|* - dereferences a Capture; junctive or, requires that a condition is fulfilled * *||* - logical or, evaluates sequentially, ends evaluation at the first expression that returns true * *~* - make string context (stringify) 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 ^^ A * *abs* - 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 * *andelse* - logical AND short circuit operator returning an Error code * *any* - junctive OR operator * _Array_ - in Perl a series of scalar values, or a variable that stores such a list * *as* - scalar method, converts like sprintf * *assuming* - method of all subroutine reference objects that enables Currying ^^ B * *before* - comparison operator used by the Order class, true when left should precede right * _Binding_ - making two variables share the same contents * _Block_ - statements enclosed by curly braces * *but* - alters properties of a variable at run time * *BUILD* - * *BUILDALL* - * *by* - sets interval for the range (..) operator * *bytes* - scalar method returns number of bytes used ^^ C * *cached* - sub trait * *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 * _capture_ - object that can contain one or more variables as they may occur in a Signature * *cat* - concatenes strings, synonym for '~' and array method * *chars* - scalar method returns number of characters * *chdir* - * *chmod* - * *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* - * *class* - declares a collection of methods that define an object * *close* - methode on Filehandle class, ending the connection with a file * _closure_ - routines whose state (content of all local variables) is completely preserved until the next execution * *cmp* - compares values textually, using the Order class * _Coderef_ - reference (pointer) to an executable block of code (routine) * _compile time_ - the process when Perl converts source code to executable form * _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* - makes execution in a 'given' also try the following 'when' clauses * *CREATE* - * _Currying_ - ^^ D * *default* - the clause executed in a given construct if no when clause matched * _Deklarative Programmierung_ - * *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 * *DESTROY* - * *DESTROYALL* - * *dim* - array dimensioning * *div* - division, creates fraction objects in Integer context * *do* - executes a block (do once loop) * *does* - pr�ft ein Objekt ob es diese role vollf�hrt ^^ E * *elems* - array method returns number of elements * *else* - introduces the alternative block after an 'if' or 'elsif' * *elsif* - alternative if clause * *eq* - equal, string comparison * *equiv* - sub trait defines the relative precedence of an operator * *eqv* - compares the dynamic state of objects and values, in contrast with static === * *err* - logical operator returns the first defined value from the left * _Exception_ - errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle * *exists* - checks for existence of a variable or hash member, scalar method ^^ F * *Failure* - data type for an error thrown by an unhandled exception * *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 * *fmt* - method on a scalar, takes a format specifier returns a string, simplified sprintf * *for* - block modifier iterates over a list * _Functional Programming_ - exclusively function based programming style ^^ G * *gather* - performs the following block once, returns a list of all values passed by 'take' * *ge* - greater than on equal, string comparison * *given* - case construct puts a value into the context variable for when clauses * *goto* - flow control, transfer execution to a defined label * *grammar* - special kind of class to hold regex token and rule definitions * *group* * *gt* - greater than or equal, string comparison ^^ H * *has* - creates an attribute for an object * *handles* - delegates execution of a function to another method * *hash* - sets hash-list context * _Hash_ - two column table, values in one column are keys to refer to the values in the other column ^^ I * *if* - flow control conditional statement or block modifier, executes code only when a condition expression evaluates to true * *index* - finds the first occurrence of a substring from a position in a string * *Inf* - infinity, to generate infinite lazy lists * *inline* - sub trait * *int* - extract a whole number value, discarding fractional part * *is* - bind a traits to a variable * _Iteration_ - flow control, repeatedly executing a block ^^ J * *join* - concatenates list elements into a string, optionally inserting another string between the elements ^^ K * *:key* - means the key part of a pair * *keys* - hash method returns list of hash keys * *kv* - hash method returns list of key-value pairs ^^ L * *last* - flow control, end the current looping block * *last* - number of final element, array method * *le* - lower than or equal, string comparison * *leave* - flow control, exit the current block * *leg* - lower/equal/greater comparator for text * *let* - * *loop* - general flow control command for repetition * *looser* - sub trait, defines relative precedence of an operator * *lt* - lower than, string comparison ^^ M * *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* - compare a string to a regex/token/rule * *max* - returns the numerically largest value from a given list * *method* - defines a method in a class * _Method_ - object oriented function or subroutine 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* - generic modulo operator * *module* - introduces a module name, a package that performs special actions on loading * *multi* - sub and method overloading modifier to allow multimethod dispatch * *my* - makes a variable or routine lexical, therefore exists and is valid only in the current scope (usually a block) ^^ N * *new* - creates a new object of a class, also name of the automatically called constructor method * *next* - looping command to go to the start of the following 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 ^^ O * _Object Oriented Programming_ - * *of* - sub trait, defines return type * *one* - junctive XOR operator * *only* - subroutine modifier, permits only a routine of the same name * *or* - logical or operator * *orelse* - logical or short circuit operator * *our* - makes a variable or subroutine name visible in all the current package ^^ P * *package* - Perl 5 namespace definition, becomes module and class in Perl 6 * *pair* - set pair context * *pairs* hash method returns all contents as an array or pairs (key,value) * _Parameter_ - value passed to a method or subroutine * *parsed* - sub trait * _Parsetree_ - hierarchical data representing the logical structure of a program * _pointy block_ - a block that is given parameters with '->' * *pop* - removes and returns the last element in an array * *print* - sends characters to an output stream without adding a newline, see 'say' * *printf* - formats text and sends it to standard output * _property_ - metadata set at runtime * *proto* - predeclaration of subroutine or method * *push* - adds a list of values to the end of an array ^^ Q ^^ R * *R* - (Meta Op) reverse operands * *rand* - generate a floating point random number between 0.0 and 1.0 * _Range Operator_ - written as '..' in scalar context defines set of possible values for smartmatch, in list context makes a list of successive values * *readline* - now called 'get', reads from an input stream until the next newline * *redo* - re-starts processing of the current loop * _Reference_ - address of data in memory, often termed a Capture in Perl 6 * *regex* - a pattern definition without :ratchet and :sigspace, can be put in a grammar, similar to qx// in Perl 5 * _Regular Expression_ - in Perl5: pattern matching notation, either regex, token or rule in Perl6 * *reparsed* - sub trait * *return* - ends a subroutine and defines the value given to the caller * *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 * *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 * *rule* - 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 ^^ S * *say* - a function like print that also appends a newline (\n) * _Scope_ - the block of code within which an identifier is usable * *:seed* - initialize a random number generator, optionally with a value * _Signatur_e - Information about the expected parameters for subroutine, in Perl6 the round parentheses after the `sub` command * *signature* - sub trait * _scalar_ - variable that holds a single value * _slice_ - part of an array * *slurp* - reads a entire file into a string * _slurpy Array_ - array parameter that receives all (slurps) all optional subroutine arguments * *split* - makes an array of substrings from a string and a separator * *sprintf* - like printf but returns the string instead of outputting it * *state* - declares variables known only in the enclosing block, that retain their values between invocations * _String_ - series of characters, text * *sub* - defines a subroutine, block modifier * *submethod* - method not inherited by subclasses * _Subroutine_ - block of code callable by name * *subset* - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 } * *substr* - the substring function ^^ T * *take* - produces a return value in a gather block * *temp* - defines variables as temporary, synonym for the Perl 5 local * *tighter* - sub trait, that indicates relative order of operator precedence * *token* - kind of regex :ratchet (no backtracking), part of a grammar * _Topicalizer_ - every keyword that sets the $_ variable, eg given, for * _Trait_ - additional property of a variable, defined at compile time, see but * *true* - boolean value * _Twigil_ - second(ary) Sigil indicating a special property of a variable ^^ U * *undef* - undefined, Perl word for 'empty' * *unless* - flow control modifier, opposite of if, runs block if expression is false * *until* - block modifier, 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 ^^ V * *values* - hash method returns an array of just the values ^^ W * *want* - produces a signature object that provides information about the context from which the current routine was called * *Whatever* - an undefined type used as wildcard (like undef) [S12] * *when* - executes its code block if a 'given' value smartmatches * *where* - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 } * *while* - flow control modifier runs block repeatedly as long as en expression is true * *wrap* - creates enveloping subroutine ^^ X * *x* - string replicate operator to single string, eg 'ab' x 3 == 'ababab' * *X* - Cross product of two arrays, eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 * *X*<op> - Cross product with hyper operator, eg <a b> X~ <y z> == <ay az by bz> * *xor* - boolean exclusive or operator * *xx* - string replicate operator to array, eg 'ab' xx 3 == <ab ab ab> ^^ Y ^^ Z * *Z* - zip operator, eg 1,2,3,4 Z 8,9 == 1,8,2,9 {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} |