Overview - Chapter 0:Intr, 1:Hist, 2:Design, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx - Appendix A:Index, B:Tables, C:Best of, D:Delta, E:Links

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

This Index contains short explanations for all Operators, Methods, Builtins and some technical Terms.

• ! - logical negation, forces binary context;
• ! - secondary sigil (twigil) on private class adn object variables
• !! - second Part of the ternary (conditional) operator after ??
• !!! - yadda Operator
• !< - not less, synonym for ">="
• !<= - not less or equal, weird synonym for ">"
• != - compare op, true if numeric unequal, short for "!=="
• !=:= - compare op, tests negated on binding
• !== - compare op, tests inequality in numeric context, negated form
• !=== - compare op, tests identity, negated form
• !> - synonym for "<="
• !>= - synonym for "<"
• !~~ - negated smartmatch operator
• !eq - synonym for "ne"
• !eqv - negated form of dynamic equivalence
• !ge - synonym for "lt"
• !gt - synonym for "le"
• !le - synonym for "gt"
• !lt - synonym for "ge"
• # - starts a comment that continues to the end of the line or bracket
• $ - scalar sigil, operator to force scalar context
• $ (regex Metachar) - end of the string
• $$ (regex Metachar) - end of a line
• % - gives remainder of a modulo division, forces numeric context; hash sigil
• & - junctive and, requires that all conditions are met; generates subref
• && - logical and, conditonal statements, ends evaluation on the first false expression, returns boolean result
• () - grouping of values (parameters)
• * - multiplies numbers and forces numeric context on parameters; marks slurpy arrays in signatures; secondary sigil for global variables; synonym for Inf 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
• ** (scalar num op) - raises a number to a power and forces numeric context
• ** (regex Metachar) - multiplies char or group like x (scalar strig op) outside of regex, (ha)**3 equals (hahaha)
• + (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) - really any character (unlike Perl 5)
• .. - range generating operator; range object in scalar context, see smartmatch table
• ... - yadda Operator
• / - division, numeric context
• // - err operator, returns the first defined value
• : - converts decimal numbers to another base; pair generation operator
• :: - name space separator (like in Perl 5)
• ::= - binding at compile time
• := - creates an alias to a variable (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
• << - 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)
• << >> - 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
• < > circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../)
• = (Op) - assignment, left side is evaluated and assigned to the right
• <op>= (meta op) - 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
• >> (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 or conditional 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
• <var>[] - 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 a limit value, in scalar context see smartmatch, in array context see array creating operators;
• ^ (twigil) - for automatically named parameters of a block
• ^ (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 '=>'
• | - 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

• a (quote adverb) - demands evaluation of array variables, short form of ":array", included in "", qq and <<>>
• 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 - junctive OR operator
• Array - in Perl a series of scalar values, or a variable that stores such a list
• array (quote adverb) - demands evaluation of array variables, long form of ":a", included in "", qq and <<>>
• as - scalar method, converts like sprintf
• 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
• assuming - method of all subroutine reference objects that enables Currying

B

• b (quote adverb) - forces evaluation of escape sequences, short form of ":backslash", included in "", qq and <<>>
• backslash (quote adverb) - forces evaluation of escape sequences, long form of ":b", included in "", qq and <<>>
• before - comparison operator used by the Order class, true when left should precede right
• BEGIN (closure trait) - special Block, is executed in compile time
• Binding - making two variables share the same contents
• Block - statements enclosed by curly braces
• but - alters properties of a variable at run time
• by - sets interval for the range (..) operator
• bytes - scalar method returns number of bytes used

C

• c (quote adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":closure", included in "", qq and <<>>
• 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
• capitalize - alias to ucirst, makes first char of every word upper case
• capture - object that can contain one or more variables as they may occur in a Signature
• cat - concatenes strings, synonym for '~' and array method
• category (grammatical category) - namespace of grammatical categories, in case you want to create a new one with a macro
• chars - scalar method returns number of characters
• chdir - changes the current working directory ($*CWD)
• 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 op) - special form of map, to sort several arrays
• close - methode on Filehandle class, ending the connection with a file
• closure (quote adverb) - 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
• code (quote adverb) - 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)
• 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
• 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 - makes execution in a 'given' also try the following 'when' clauses
• Currying - creating a subroutine as a derivate from another with certain parameter to be predefined

D

• default - the clause executed in a given construct if no when clause 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
• 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) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, long for ":qq"

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 as equivalent of an other (given as Parameter)
• 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
• exec (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :x and qx //
• exists - checks for existence of a variable or hash member, scalar method

F

• f (quote adverb) - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":function", included in "", qq and <<>>
• Failure - data type for an error thrown by an unhandled exception
• false - boolean value aka Bool::False
• 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
• flip (scalar string op) - revers strings on character level
• fmt - method on a scalar, takes a format specifier returns a string, simplified sprintf
• for (block modifier) - iterates over a list
• function (quote adverb) - 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

G

• 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 - 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

• h (quote adverb) - demands evaluation of hash variables, long form of ":hash", included in "", qq and <<>>
• has - creates an attribute for an object
• handles - delegates execution of a function to another method
• Hash - two column table, values in one column are keys to refer to the values in the other column
• hash - sets hash-list context
• hash (quote adverb) - demands evaluation of hash variables, long form of ":h", included in "", qq and <<>>
• heredoc (quote adverb) - defines end marker for the following heredoc, :heredoc is equal to :to

I

• if (block modifier) - 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
• infix (grammatical category) - operator namespace of ops, that are surrounded by whitespace (\w) between 2 vars or statements ($a + $b)
• inline (sub trait) -
• int - extract a whole number value, discarding fractional part
• invert (hash method) - inverts the key => value relation of pairs and hashes
• is - bind a traits to a variable
• Iteration - flow control, repeatedly executing a block

J

• join (array method & op) - concatenates list elements into a string, optionally inserting another string between the elements

K

• key (pair method) - gives 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 (array method) - number of final element
• 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 (flow control) - exit the current block
• 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 iterator over all lines of that input stream, for lazy retrieval
• loop (block modifier) - general flow control command for repetition
• looser (sub trait) - defines relative precedence of an operator as lesser than another (given as Parameter)
• lt (string comparison op) - 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, alias to smartmatch operator (~~)
• max (list op) - returns the numerically largest value from a given list
• maybe (block modifier) -
• 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 (block modifier) - 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 - programming paradigm (style), that arranges data and functions that belong together into so called objects
• 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, transferring an Error code from first to second block/command, if first do not succeed
• our - makes a variable or subroutine name visible in all the current package

P

• p5=> (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 - force 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) - 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
• pick (array method) - select a number of random vaues
• pointy block - a block that is given parameters with '->'
• pop (array op & method) - removes and returns the last element in an array
• 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++)
• 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 - reading a line from $*IN formerly STDIN
• property - metadata set at runtime
• proto - predeclaration of subroutine or method
• push (array op & method) - adds a list of values to the end of an array

Q

• Q - generalized quoting op, understands a list of adverbs
• q (quoting op) - simple quoting (slashes and '), alias to '...' and Q :q /.../ and Q :single /.../
• q (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, short for ":single"
• qq (quoting op) - 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) - 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) - splits result on words (as in P5), alias to Q :q :w //
• qx (quoting op) - execute as command and return results (as in P5), alias to Q :x //
• 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) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), long form of ":quotewords", used in < ... > and << ... >>

R

• R<op> (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) - 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"
• 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 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
• rule - alais 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
• rx (quote op) - regex operator, to assign a regex into a var, creates (anonymous) regex for searching a string, alias to Q :regex // and regex (block modificator)

S

• s (quote op) - subst operator, to assign a regex into a var, creates (anonymous) regex for replacing operations, alias to Q :subst // and subst (block modificator)
• s (quote adverb) - demands evaluation of hash variables, long form of ":scalar", included in "", qq and <<>>
• 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
• sigil (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro
• Signature - Information about the expected parameters for subroutine, in Perl6 the round parentheses after the sub command
• signature (sub trait) -
• single (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q"
• scalar - variable that holds a single value
• scalar (quote adverb) - demands evaluation of scalar variables, long form of ":s", included in "", qq and <<>>
• 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
• 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
• state - declares variables known only in the enclosing block, that retain their values between invocations
• String - series of characters, text
• sub (block modifier) - defines a subroutine
• 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///
• substr - the scalar substring function like in Perl 5

T

• 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
• tighter (sub trait) - defines relative precedence of an operator as higher than another (given as Parameter)
• to (quote adverb) - 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
• tr (quote op) - 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 (quote adverb) - evals the quoted as transliteration aka tr ///
• true (Op) - 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 - 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

U

• uc - make string uppercase
• ucfirst - make first char of a string uppercase
• undef - undefined, Perl word for 'empty'
• unless (block modifier) - 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

• value (pair method) - gets value (second) value of a pair
• values hash method - returns an array of just the values

W

• w (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, short form of ":words", used in qw//
• 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 (block modifier) - executes its code block if a 'given' value smartmatches
• where - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 }
• while (block modifier) - flow control modifier runs block repeatedly as long as en expression is true
• words (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, long form of ":w", used in qw//
• wrap - creates enveloping subroutine
• ww (quoting adverb) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), short form of ":quotewords", used in < ... > and << ... >>

X

• X (list op) - Cross product of two arrays, eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 ; alias of comb method
• X<op> (meta op) - Cross product with hyper operator, eg <a b> X~ <y z> == <ay az by bz>
• x (scalar string op) - string replicate operator to single string, eg 'ab' x 3 == 'ababab'
• x (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :exec and qx //
• xor (scalar bool op) - boolean exclusive or operator
• xx (scalar string op) - string replicate operator to array, eg 'ab' xx 3 == <ab ab ab>

Y

Z

• Z (list op) - alias to zip (list op)
• zip (list op) - zip operator, joines 2 lists eg 1,2,3,4 Z 8,9 == 1,8,2,9

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

Overview - Chapter 0:Intr, 1:Hist, 2:Design, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx - Appendix A:Index, B:Tables, C:Best of, D:Delta, E:Links