Perl 6
Perl 6 Index Tablet: Revision 1

Overview - Chapter: 0:Intr, 1:Hist, 2:Design, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx - Appendices: 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 an alphanumeric sorted list of all operators, methods, builtins, options (bold) and some technical terms (italic) with short explanations. Each bold term is followed by a link to a condensed summary of its category in appendix B.

  • ! - logical negation, forces binary context;
  • ! (twigil) - twigil of private class and object variables
  • !! - second Part of the ternary (conditional) operator after ??
  • !!! (yadda op) - yadda Operator that calles die
  • !< - 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"
  • "" (quoting op) - 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
  • $ (sigil) - prefix of scalar vars, operator to force scalar context
  • $ (regex Metachar) - end of the string
  • $$ (regex Metachar) - end of a line
  • % (sigil) - prefix of hash variables
  • % - gives remainder of a modulo division, forces numeric context
  • & (conext op) - sigil of coderefs
  • & - junctive and, requires that all conditions are met
  • && - logical and, conditonal statements, ends evaluation on the first false expression, returns boolean result
  • '' (quoting op) - simple quoting, just / and ' needs o be quoted, alias to q//
  • () - grouping of values (parameters)
  • () (regex Metachar) - 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) - secondary sigil of global variables
  • ** (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)
  • + (conext op), (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 op) - yadda Operator that calles fail (exception)
  • / - division, numeric context
  • // - err operator, returns the first defined value
  • : - pair generation operator
  • : (filetest op) - 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) - 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)
  • :: - 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
  • << (meta op) - 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) - 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) - 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
  • >> (meta op) - binds operator (right) as hyper operator to an array (left)
  • ? (conext op) - forces binary context in an expression
  • ? - marks as postfix optional parameters in signatures
  • ? - quantifier for 0 or 1 occurrence in Regexes
  • ? (twigil) - 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) - sigil of an array
  • @@ (conext op) - sigil for multislice context, meaning an array that may contain array references
  • <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) - circumfix reduction metaop, close to functional "reduce", applies the operator between all elements of an array
  • [\ ] (meta op) - 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 and regexes start with it
  • ^ - 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 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
  • | (conext op) - dereferences a capture into capture context
  • || - logical or, evaluates sequentially, ends evaluation at the first expression that returns true
  • ~ (conext op), (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

A

  • A (filetest op) - Script start time minus file access time, in days
  • a (quoting adverb) - demands evaluation of array variables, short form of ":array", included in "", qq and <<>>
  • a (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":ignoreaccent"
  • aa (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 - junctive OR operator
  • Array - in Perl a series of scalar values, or a variable that stores such a list
  • array (quoting 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 (filetest op) - file is a binary data file (opposite of :T)
  • b (filetest op) - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)
  • b (quoting adverb) - forces evaluation of escape sequences, short form of ":backslash", included in "", qq and <<>>
  • backslash (quoting 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
  • break - leave this when clause now
  • but - alters properties of a variable at run time
  • by - sets interval for the range (..) operator
  • bytes (scalar sring method) - returns number of bytes used (a sort of length)
  • bytes (regex modifier) - searching on byte level, (see also chars, codes, graphs)

C

  • C (filetest op) - Script start time minus inode change time (Unix, may differ for other platforms)
  • c (filetest op) - file is a character special file (e.g. terminals modems)
  • c (quoting adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":closure", included in "", qq and <<>>
  • c(<n>) (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"
  • cached (sub trait) - marks memoized routines, or at least memoizable
  • 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 - 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 string method) - returns number of characters
  • chars (regex modifier) - searching on character level (default), (see also bytes, codes, graphs)
  • 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 (quoting 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 (quoting 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)
  • codes (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
  • 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) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":c"
  • Currying - creating a subroutine as a derivate from another with certain parameter to be predefined

D

  • d (filetest op) - check if file is a directory
  • 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

  • e (filetest op) - tests if file exists
  • 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
  • ex (regex modifier) - searching at all positions as long as it findes something (with backtracking), short for ":exhaustive"
  • 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 //
  • exhaustive (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

F

  • f (filetest op) - file is a plain file (no socket or dir, ...etc.)
  • f (quoting 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 (quoting 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

  • g (filetest op) - report if file has setgid bit set
  • g (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 - case construct puts a value into the context variable for when clauses
  • global (regex modifier) - searching for any finding (not just the first), long for :g
  • goto (flow control) - transfer execution to a defined label
  • grammar - special kind of class to hold regex token and rule definitions
  • graphs (regex modifier) - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
  • group -
  • gt - greater than or equal, string comparison

H

  • h (quoting 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 (quoting adverb) - demands evaluation of hash variables, long form of ":h", included in "", qq and <<>>
  • heredoc (quoting adverb) - defines end marker for the following heredoc, :heredoc is equal to :to

I

  • i (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) - flow control conditional statement or block modifier, executes code only when a condition expression evaluates to true
  • ignoreaccent (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":a"
  • ignorecase (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) - 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)
  • 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

  • k (filetest op) - report if file has sticky bit set
  • keepall (regex modifier) - forces subrules to memorize everything (even comments)
  • 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

  • l (filetest op) - file is a symbolic link
  • 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
  • lines (io op) - reads a file and returns content as array of lines
  • 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

  • M (filetest op) - Script start time minus file modification time, in days
  • m (regex quoting op) - perform a regex based search in place ( stands for match ), similar to rx (quote regex op)
  • 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 (~~)
  • match object - result of an regex operation
  • 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
  • mm (regex quoting op) - perform a regex based search in place, spaces are just subrule separators, alias to m:sigspace /.../
  • mod (scalar op) - generic modulo operator
  • module (block modifier) - introduces a module name, a package that performs special actions on loading
  • multi (routine modifier) - sub and method overloading modifier to allow multimethod dispatch
  • my (var scope) - makes a variable or routine lexical, therefore exists and is valid only in the current scope (usually a block)

N

  • <n> nd (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 (flow control) - 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

  • O (filetest op) - tests if file is owned by real uid
  • o (filetest op) - 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 (sub trait) - defines return type, eg subset Month of Int where { 1 <= $^a <= 12 }
  • 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 (var scope) - makes a variable or subroutine name visible in all the current package
  • ov (regex modifier) - searching at all positions just one time (with backtracking), short for ":overlap"
  • overlap (regex modifier) - searching at all positions just one time (with backtracking), long for ":ov"

P

  • p (filetest op) - file is a named pipe (FIFO), or filehandle is a pipe
  • p(<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), short for ":pos"
  • P5 (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 - data type
  • pair (context op) - force pair context
  • pairs (hash method) - returns all contents as an array or pairs (key,value)
  • panic (regex modifier) - overwriting a possible set :ratchet for all subrules (activates backtracking)
  • 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
  • Perl5 (regex modifier) - activate old Perl 5 regex rules, alias to :P5* pick (array method) - select a number of random vaues
  • 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) - searching only on the nth (n is an int) position (counting from 0), long for ":p"
  • 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"
  • 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 << ... >>
  • 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 //

R

  • R<op> (meta op) - reverse operands
  • R (filetest op) - check if file is readable by real uid/gid
  • r (filetest op) - check if file is readable by effective uid/gid
  • 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
  • ratchet (regex modifier) - deactivates backtracking, search starts at pos, where last match ended
  • <n> rd (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
  • redo - re-starts processing of the current loop
  • Reference - address of data in memory, often termed a Capture in Perl 6
  • 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) - parse as quoted string as regex
  • 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 (flow control) - 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
  • rw - (Routine Trait) means read/write,
  • rw (regex modifier) - gives the regex the right to change the string (operand)
  • rx (regex quoting op) - creates anonymous regex, that can me then assigned into a var, alias to Q :regex // and regex (block modificator)

S

  • S (filetest op) - file is a socket
  • s (filetest op) - returns file size in bytes
  • s (quoting adverb) - demands evaluation of scalar variables, long form of ":scalar", included in "", qq and <<>>
  • s (regex quoting op) - perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst // and subst (block modificator)
  • s (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, short for ":sigspace", mm// is alias to m:sigspace//
  • sameaccent (regex modifier) - only for substitutions, replacing with chars that have the same accent pattern as the replaced, long for ":aa"
  • samecase (regex modifier) - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for ":ii"
  • samespace (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)
  • 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) -
  • sigspace (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) - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q"
  • scalar - variable that holds a single value
  • scalar (quoting adverb) - demands evaluation of scalar variables, long form of ":s", included in "", qq and <<>>
  • slice - part of an array
  • slurp (io op) - 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
  • ss (regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:samespace/.../.../
  • ss (regex modifier) - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for ":samespace", ss// is alias to s:samespace///, (ss/teh hsa/the has/;)
  • <n> st (regex modifier) - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st)
  • 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///
  • subst (quoting adverb) - parse as substitution
  • substr - the scalar substring function like in Perl 5

T

  • T (filetest op) - file is an ASCII text file (heuristic guess), (opposite of :B)
  • t (filetest op) - filehandle is opened to a tty (terminal)
  • 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) - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd)
  • tighter (sub trait) - defines relative precedence of an operator as higher than another (given as Parameter)
  • to (quoting 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 (quoting 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 (quoting adverb) - evals the quoted as transliteration aka tr ///
  • 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 - 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

  • u (filetest op) - report if file has setuid bit set
  • uc - make all string chars 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 (loop 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 (filetest op) - check if file is writeable by real uid/gid
  • w (filetest op) - check if file is writeable by effective uid/gid
  • 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 (filetest op) - check if file is executable by real uid/gid
  • x (filetest op) - check if file is executable by effective uid/gid
  • 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 //
  • x(<n>) (regex modifier) - searching n times (n is an int) with this pattern
  • 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>

Y

  • yadda operator - placeholder for later to be written code, because in empty routines are forbidden

Z

  • Z (list op) - alias to zip (list op)
  • z (filetest op) - tests if file is empty (zero size)
  • 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 - Appendices: A:Index, B:Tables, C:Best of, D:Delta, E:Links



Upload Files

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

Maximum file size: 50MB

 
 
 
File Name Author Date Uploaded Size

Save Page As

Enter a meaningful and distinctive title for your page.

Page Title:

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

Page Already Exists

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

Save with a different name:

Save the page with the name "XXX"

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

Upload Files

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

 
 
 
Add Tags

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

Tag: 

Suggestions: